0:\n order[order_item_identifier] = quantity\n print(str(order_item_identifier))\n else:\n order.pop(order_item_identifier)\n request.session['order'] = order\n return redirect(reverse('orders'))","def set_status(self, status):\n # TODO log to db\n self.status = status","def make_active(self, request, queryset):\n queryset.update(is_active=True)","def set_status(self, status):\n self.status = status"],"string":"[\n \"def order_ready(request):\\n\\tcs , status = CookStatus.objects.get_or_create(cook_name=request.user)\\n\\tif cs.current_order is not None:\\n\\t\\tcs.current_order.status = 'ready-to-serve'\\n\\t\\tcs.current_order.save()\\n\\t\\tcs.current_order = None\\n\\t\\tcs.save()\\n\\n\\treturn HttpResponseRedirect(\\\"/staff/cook_order_list/\\\")\",\n \"def mark_completed(self, order_id=None):\\n self.status = \\\"paid\\\"\\n if order_id and not self.order_id:\\n self.order_id = order_id\\n print(\\\"Order completed\\\")\\n self.save()\",\n \"def change_status(id):\\n query = \\\"\\\"\\\"UPDATE parcels SET status = %s WHERE id = %s\\\"\\\"\\\"\\n tuple =('delivered' , id)\\n db.insert(query, tuple)\",\n \"def update_specific_order(self,status,order_id):\\n self.query = \\\"UPDATE orders SET order_status=%s WHERE order_id=%s\\\"\\n self.input = (status,order_id) #tuple to support indexing\\n self.query_1 = \\\"SELECT order_id FROM orders ORDER BY order_id DESC LIMIT 1.\\\"\\n self.query_2 = \\\"SELECT * FROM orders WHERE order_id=%s\\\"\\n self.input_2 = (order_id,) #tuple to support indexing\\n self.event = \\\"admin_update_specific_order\\\"\\n self.error = \\\"Invalid order id\\\"\\n self.message = \\\"Successfully updated the order.\\\"\\n self.order_id = order_id\\n self.db_error = None\",\n \"def put(self, order_id):\\n body = request.get_json()\\n order = db.session.query(models.Order).filter_by(id=order_id).first()\\n if order is None:\\n return 'Order id not found', 400\\n borrower = body.get('borrower')\\n borrower = query_user_by_name(borrower)\\n if borrower is None:\\n return 'User does not exit in the system', 404\\n # if invalid_user(borrower.username):\\n # return 'Unauthorized user, please login as a user/borrower', 401\\n copy_id = body.get('copy_id')\\n print(body)\\n print(copy_id)\\n copy = db.session.query(models.Copy).filter_by(id=copy_id).first()\\n if copy is None:\\n return 'Copy ID {} not found in system'.format(copy_id), 409\\n elif copy.id != copy_id and copy.status == BOOK_COPY_STATUS_UNAVAILABLE:\\n return 'The copy of the book is not available', 400\\n copy_owner = body.get('copy_owner')\\n owner = query_user_by_name(copy_owner)\\n if owner is None:\\n return 'Copy owner not found in the system'.format(copy_owner), 409\\n # return_date = body.get('return_date')\\n # if datetime.strptime(return_date, \\\"%y%m%d\\\") < datetime.strptime(datetime.utcnow().strftime(\\\"%Y-%m-%d\\\"), \\\"%y%m%d\\\"):\\n # return 'Return date should be later than today', 400\\n status = body.get('order_status')\\n if status is not None and status < 0 or status > 4:\\n return 'Status should between 0-4', 400\\n order.parse_body_status(body)\\n copy = db.session.query(models.Copy).filter_by(id=order.copy).first()\\n if order.status == ORDER_STATUS_COMPLETED or order.status == ORDER_STATUS_DECLINED:\\n copy.status = BOOK_COPY_STATUS_AVAILABLE\\n else:\\n copy.status = BOOK_COPY_STATUS_UNAVAILABLE\\n db.session.commit()\\n return order.serialize(), 200\",\n \"def test_manager_change_order_status(self):\\n self.client.force_authenticate(self.user)\\n cancel = \\\"CA\\\"\\n url = reverse('order-set_status', args=[self.order.id])\\n resp = self.client.patch(url, data={\\n \\\"status\\\": cancel\\n })\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n new_status = Order.objects.values(\\\"status\\\").get(pk=self.order.id)\\n self.assertEqual(new_status[\\\"status\\\"], cancel)\\n\\n with self.subTest('customer can not change order status'):\\n self.user.role = get_user_model().CUSTOMER\\n self.client.force_authenticate(self.user)\\n resp = self.client.patch(url, data={\\n \\\"status\\\": cancel\\n })\\n self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)\",\n \"def UpdateStatus(self,pid):\\n\\t\\tb1=Rents.objects.filter(paymentid_id=pid).first()\\n\\t\\tamount=Payment.objects.filter(paymentid=pid).values('amount')\\n\\t\\tb=b1.__dict__\\n\\t\\tquant=b['quantity']\\n\\t\\tbookid=b['bookid_id']\\n\\t\\tprice=amount[0]['amount']/quant\\n\\t\\t#price=float(\\\"{.2f}\\\".format(amount[0]['amount']))/float(\\\"{0:.2f}\\\".format(quant))\\n\\t\\tRents.objects.filter(paymentid_id=pid).update(status='r')\\n\\t\\tBook.objects.filter(bookid=bookid).update(quantity=F('quantity')+quant)\\n\\t\\tStatus.objects.filter(ISBN=b['ISBN'],rentprice=price).update(quantity=F('quantity')+quant)\\n\\t\\tUpload.objects.filter(owner_id_id=b['owner_id_id'],sellprice=price).update(qtyavailable=F('qtyavailable')+quant)\\n\\t\\tself.notifyBuyer(b['ISBN'])\",\n \"def order_update_status():\\n result = order_obj.order_update_status(request.forms) \\n return result\",\n \"def cook_order_list(request):\\n\\tall_orders = Order.objects.all().order_by(\\\"-id\\\")\\n\\tcss = CookStatus.objects.filter(cook_name=request.user)\\n\\tcs = None\\n\\tcurrent_order = None\\n\\tif len(css) != 0:\\n\\t\\tcs = css[0]\\n\\t\\tif cs.current_order != None :\\n\\t\\t\\tcurrent_order = cs.current_order.menu_items.all()\\n\\n\\tnew_orders = []\\n\\tfor order in all_orders:\\n\\t\\ta = {}\\n\\t\\ta['id'] = order.id\\n\\t\\ta['status'] = order.status\\n\\n\\t\\ta['timespan'] = (datetime.datetime.utcnow().replace(tzinfo=utc) - order.timestamp_created).seconds\\n\\t\\tcookofthis = CookStatus.objects.filter(current_order=order)\\n\\t\\tif len(cookofthis) != 0:\\n\\t\\t\\ta['cookname'] = cookofthis[0].cook_name.username\\n\\t\\telif order.tikchen != None:\\n\\t\\t\\ta['cookname'] = order.tikchen\\n\\n\\t\\tnew_orders.append(a)\\n\\n\\n\\treturn render_to_response('staff/cook_order_list.html', \\n\\t\\t{'all_orders':new_orders, 'user':request.user, 'current_order':current_order})\",\n \"async def update_order_status():\\n symbol = App.config[\\\"symbol\\\"]\\n\\n # Get currently active order and id (if any)\\n order = App.order\\n order_id = order.get(\\\"orderId\\\", 0) if order else 0\\n if not order_id:\\n log.error(f\\\"Wrong state or use: check order status cannot find the order id.\\\")\\n return None\\n\\n # -----\\n # Retrieve order from the server\\n try:\\n new_order = App.client.get_order(symbol=symbol, orderId=order_id)\\n except Exception as e:\\n log.error(f\\\"Binance exception in 'get_order' {e}\\\")\\n return\\n\\n # Impose and overwrite the new order information\\n if new_order:\\n order.update(new_order)\\n else:\\n return None\\n\\n # Now order[\\\"status\\\"] contains the latest status of the order\\n return order[\\\"status\\\"]\",\n \"def Cook(self, env, customer, cooking_time_type = 'fixed', manual_cook_time = None):\\n with self.resource.request() as req:\\n yield req #resource를 점유 해야 함.\\n now_time = round(env.now , 1)\\n req.info = [customer.name, now_time]\\n if cooking_time_type == 'fixed':\\n cooking_time = self.order_ready_time\\n elif cooking_time_type == 'random':\\n cooking_time = random.randrange(1,self.order_ready_time)\\n elif cooking_time_type == 'uncertainty':\\n cooking_time = customer.cook_time\\n else:\\n cooking_time = 0.001\\n print('T :{} 가게 {}, {} 분 후 주문 {} 조리 완료'.format(int(env.now),self.name,cooking_time,customer.name))\\n if manual_cook_time == None:\\n yield env.timeout(cooking_time)\\n else:\\n yield env.timeout(manual_cook_time)\\n print('T :{} 가게 {} 주문 {} 완료'.format(int(env.now),self.name,customer.name))\\n customer.food_ready = True\\n customer.ready_time = env.now\\n self.ready_order.append(customer)\",\n \"def test_updating_item_status(self):\\n #test original quantity\\n self.assertEqual(self.supply1.quantity, 10)\\n self.assertEqual(self.supply2.quantity, 10)\\n \\n modified_po = copy.deepcopy(base_purchase_order)\\n modified_po['status'] = 'Received'\\n modified_po['items'][0]['id'] = 1\\n modified_po['items'][0]['status'] = 'Receieved'\\n \\n resp = self.client.put('/api/v1/purchase-order/1/',\\n format='json',\\n data=modified_po)\\n \\n self.assertEqual(resp.status_code, 200, msg=resp)\\n \\n po = resp.data\\n \\n self.assertEqual(Supply.objects.get(pk=1).quantity, 20)\",\n \"def set_order_status(self, status, orderid=0, envtype=0):\\n if int(status) not in TRADE_CN.REV_ORDER_STATUS:\\n error_str = ERROR_STR_PREFIX + \\\"the type of status is wrong \\\"\\n return RET_ERROR, error_str\\n\\n if not TRADE_CN.check_envtype_cn(envtype):\\n error_str = ERROR_STR_PREFIX + \\\"the type of environment param is wrong \\\"\\n return RET_ERROR, error_str\\n\\n query_processor = self._get_sync_query_processor(SetOrderStatusCN.cn_pack_req,\\n SetOrderStatusCN.cn_unpack_rsp)\\n\\n # the keys of kargs should be corresponding to the actual function arguments\\n kargs = {'cookie': str(self.cookie), 'envtype': str(envtype), 'localid': str(0),\\n 'orderid': str(orderid), 'status': str(status)}\\n\\n ret_code, msg, set_order_list = query_processor(**kargs)\\n if ret_code != RET_OK:\\n return RET_ERROR, msg\\n\\n col_list = ['envtype', 'orderID']\\n set_order_table = pd.DataFrame(set_order_list, columns=col_list)\\n\\n return RET_OK, set_order_table\",\n \"def status(self, id):\",\n \"def change_status(self, status, application_id):\",\n \"def make_coffee(self, order):\\n for item in order.ingredients:\\n self.resources[item] -= order.ingredients[item]\\n print(f\\\"Here is your {order.name} ☕️. Enjoy!\\\")\",\n \"def test_update_order(self):\\n response = self.api_test_client.put('{}/orders/1'.format(\\n self.BASE_URL), json={'order_status': 'accepted'})\\n\\n self.assertEqual(response.status_code, 201)\\n self.assertTrue(\\n response_as_json(response)['order']['status_updated_on'])\\n self.assertEqual(\\n response_as_json(response)['order']['order_status'], 'accepted')\",\n \"def make_coffee(self, order):\\n for item in order.ingredients:\\n self.resources[item] -= order.ingredients[item]\\n print(f\\\"Here is your {order.name} ☕️. Enjoy!\\\")\",\n \"def set_OrderStatus(self, value):\\n super(ListOrdersInputSet, self)._set_input('OrderStatus', value)\",\n \"def return_item(self,reason):\\n if reason == \\\"defective\\\":\\n self.status = \\\"defective\\\"\\n self.price = 0\\n elif reason == \\\"unopened\\\":\\n self.status = \\\"for sale\\\"\\n else:\\n self.status = \\\"used\\\"\\n self.price -= (.20 * self.price)\\n return self\",\n \"def update_order():\",\n \"def update_order():\",\n \"def onOrderSelected(self, item):\\n if self.lstOrders.getMultiSelectedItems() == []:\\n self.clearBidData()\\n else:\\n self.btnCancelOrder.enable()\",\n \"def update_order(self, order):\\n order.order_id = self.order_id\\n order.average_price = self.avg_execution_price\\n order.symbol = self.symbol\\n order.side = self.side\\n order.type = self.order_type\\n order.amount = self.original_amount\\n order.price = self.price\\n order.filled = self.executed_amount\\n order.remaining = self.remaining_amount\\n if self.is_cancelled:\\n order.status = exchanges.Order.Status.CANCELLED\\n elif self.is_live:\\n order.status = exchanges.Order.Status.OPEN\\n else:\\n order.status = exchanges.Order.Status.CLOSED\\n return order\",\n \"def test_order_update_status_function(self):\\n order = OrderInfo.objects.create(user=self.create_test_user())\\n self.assertIsInstance(order.ordered, datetime)\\n self.assertIsNone(order.cooked)\\n self.assertIsNone(order.delivered)\\n\\n order.update_current_state()\\n self.assertIsInstance(order.cooked, datetime)\\n self.assertIsNone(order.delivered)\\n\\n order.update_current_state()\\n self.assertIsInstance(order.cooked, datetime)\\n self.assertIsInstance(order.delivered, datetime)\",\n \"def onChange(self, customer, pizza_id):\\n \\n pizza_qty = self.vars[pizza_id].get()\\n customer.ChangePizzaQTY(pizza_id, pizza_qty)\\n self.showOrderPrice(customer.my_order)\",\n \"def fill_order(self, order: Order) -> None:\\n order = self.get_order_by_id(order.id)\\n order.status = OrderStatus.FILL\",\n \"def put(self):\\n request_data = json.loads(request.data)\\n print(request_data)\\n order_id = request_data['order_id']\\n status = request_data['status']\\n MM.update_order_status(ObjectId(order_id), status)\\n return {\\\"message\\\": \\\"Order Status Updated\\\"}, 200\",\n \"def onSelected(self, item):\\n if not item:\\n self.clearBidData()\\n else:\\n self.enableAddOrder()\",\n \"def finish_order(self, order_id):\\n request_name = \\\"get_order_info\\\"\\n\\n orders = self.make_request(request_name, url_id=order_id)\\n if orders is None:\\n print(\\\"Unsuccessful updating order\\\")\\n return\\n order = orders[0]\\n update_dict = dict()\\n for key in order:\\n if str(key)[0] == \\\"_\\\":\\n continue\\n try:\\n update_dict[key.encode('utf-8')] = order[key].encode('utf-8')\\n except AttributeError:\\n update_dict[key.encode('utf-8')] = order[key]\\n\\n update_dict['status'] = 'Complete'\\n resp = self.make_request('set_inventory_order', url_id=order_id, arguments=update_dict)\",\n \"def change_to_shopping(self):\\n self.ids[\\\"tsk_btn\\\"].color = 1, 1, 1, 0.5\",\n \"def set_order_done():\\n data = select_data_source()\\n user = data['user']\\n order_id = data['id']\\n \\n if check_user_permission(user) : return permission_denied_return\\n \\n db = database.getdb()\\n \\n ### Check if is valid.\\n \\n cmd = 'select passed from orders where id==\\\"{0}\\\"'.format(order_id)\\n order_valid = db.execute(cmd).fetchall()[0][0]\\n if order_valid == 0 :\\n return finish_invalid_return\\n \\n ### Check if is done.\\n cmd = 'select done from orders where id==\\\"{0}\\\"'.format(order_id)\\n order_done = db.execute(cmd).fetchall()[0][0]\\n if order_done != 0 :\\n return finish_done_return\\n \\n ### All check done.\\n ### Set it to done.\\n cmd = 'update orders set done=1 where id==\\\"{0}\\\"'.format(order_id)\\n db.execute(cmd)\\n db.commit()\\n print('user sets order {0} to be done.'.format(user))\\n \\n return finish_complete_return\",\n \"def update_status(self, id, status):\\n sql = f\\\"UPDATE incidences SET status = \\\\'{status}\\\\'\\\\\\n WHERE incidences.id = {id}\\\"\\n conn = Db().con\\n curr = conn.cursor()\\n curr.execute(sql)\\n conn.commit()\",\n \"def test_admin_change_order_status(self):\\n # Test unregistered id\\n # Correct format but not there\\n response = self.client.put(\\n 'api/v1/parcels/35420', headers=self.admin_token_dict)\\n data = json.loads(response.data)\\n self.assertEqual(response.status_code, 400)\\n self.assertEqual(\\n data, {'message': 'No Parcel delivery order with that id'})\\n # Test invalid format id\\n response = self.client.put(\\n 'api/v1/parcels/35uh420', headers=self.admin_token_dict) # Incorrect id format\\n data = json.loads(response.data)\\n self.assertEqual(response.status_code, 400)\\n self.assertEqual(data, {'message': 'Wrong id format'})\",\n \"def sell(self):\\n self.status = \\\"sold\\\"\\n return self\",\n \"def item_status(item_id):\\n\\n item_completed = request.form.get(\\\"item_completed\\\", \\\"off\\\")\\n list_id = request.form[\\\"list_id\\\"]\\n\\n item_completed = item_completed == \\\"on\\\"\\n\\n to_do_item = ToDoItem.query.get(item_id)\\n to_do_item.completed = item_completed\\n db.session.commit()\\n\\n return redirect(f\\\"/lists/{list_id}\\\")\",\n \"def chase_order(self, order_id, side, avg, qty=None):\\n sleep(1) # takes a second for order_id to register in bitmex trade engine\\n last_price = avg\\n max_chase_buy = float(avg) + float(self.strategy.chase)\\n max_chase_sell = float(avg) - float(self.strategy.chase)\\n self.logger.info(f'Chasing {side} order, initial price: {avg}, chase: {self.strategy.chase}, '\\n f'Failsafe: {self.strategy.chase_failsafe} ')\\n\\n while True:\\n # o = self.rest_open_order(orderID=order_id)\\n o = self.ws_open_order(oid=order_id)\\n if o:\\n if side == 'Buy':\\n if self.strategy.double_check or self.ws_restarting:\\n quote = self.get_quote()\\n self.logger.info('Bid: {} Ask: {}'.format(quote['bidPrice'], quote['askPrice']))\\n _price = quote['bidPrice']\\n else:\\n _price = self.ws.get_ticker()['buy']\\n\\n self.logger.debug(\\n f'Chasing buy order {order_id}, order_price: {avg}, last_price: {last_price}, current price: '\\n f'{_price} max chase: {max_chase_buy}')\\n if float(_price) <= float(max_chase_buy):\\n if float(last_price) < float(_price):\\n self.logger.info(f'Amending order {order_id} to price {_price}')\\n try:\\n ret = self.client.Order.Order_amend(orderID=order_id, price=_price).result()\\n except Exception as fuck:\\n self.logger.info(f'Error: {fuck}')\\n else:\\n self.logger.debug(ret)\\n finally:\\n last_price = _price\\n else:\\n self.logger.debug(f'Sleeping, order_price: {last_price}, current price: {_price}')\\n if self.strategy.double_check:\\n sleep(0.5)\\n\\n else:\\n if self.strategy.chase_failsafe:\\n self.logger.info(f'Price {_price} exceeded max chase {max_chase_buy}, buying market.')\\n self.client.Order.Order_cancelAll(symbol=self.strategy.symbol).result()\\n self.execute_order(oq=qty, ot='market', text='Chase failsafe market long order')\\n else:\\n self.logger.info(f'Price {_price} exceeded max chase {max_chase_buy}, giving up.')\\n break\\n elif side == 'Sell':\\n if self.strategy.double_check or self.ws_restarting:\\n quote = self.get_quote()\\n self.logger.info('Bid: {} Ask: {}'.format(quote['bidPrice'], quote['askPrice']))\\n _price = quote['askPrice']\\n else:\\n _price = self.ws.get_ticker()['sell']\\n\\n self.logger.debug(\\n f'Chasing sell order {order_id}, order_price: {avg}, last_price: {last_price}, current price: '\\n f'{_price} max chase: {max_chase_sell}')\\n if float(_price) >= float(max_chase_sell):\\n if float(last_price) > float(_price):\\n self.logger.info(f'Amending order {order_id} to price {_price} ')\\n try:\\n ret = self.client.Order.Order_amend(orderID=order_id, price=_price).result()\\n except Exception as fuck:\\n self.logger.info(f'Error: {fuck}')\\n else:\\n self.logger.debug(ret)\\n finally:\\n last_price = _price\\n else:\\n self.logger.debug(f'Sleeping, order_price: {last_price}, current price: {_price}')\\n if self.strategy.double_check:\\n sleep(0.5)\\n\\n else:\\n if self.strategy.chase_failsafe:\\n self.logger.info(f'Price {_price} exceeded max chase {max_chase_sell}, selling market.')\\n self.client.Order.Order_cancelAll(symbol=self.strategy.symbol).result()\\n self.execute_order(oq=qty, ot='market', text='Chase failsafe market short order')\\n else:\\n self.logger.info(f'Price {_price} below max chase {max_chase_sell}, giving up.')\\n break\\n else:\\n self.logger.info('Order Filled')\\n break\",\n \"def change_status(self):\\n if self.status == \\\"Still Loaned\\\":\\n self.status = \\\"Given Back\\\"\\n else:\\n self.status = \\\"Still Loaned\\\"\",\n \"def api_mark_order_ready(request, id):\\n\\n close_old_connections()\\n \\n # Not marking it as served if it isn't even ready yet.\\n if not request.user.is_authenticated:\\n return HttpResponseForbidden(\\\"You're not authenticated.\\\")\\n \\n # Get the order.\\n order = Order.objects.get(id=id)\\n \\n # Mark the order as served and save it.\\n order.ready = not order.ready\\n order.save()\\n\\n close_old_connections()\\n\\n return HttpResponse('Marked as ready')\",\n \"def set_add_dispute_status(self, status):\\n self.single_selection_from_kendo_dropdown(self.add_dispute_status_kendo_dropdown_locator, status)\\n self.wait_for_ajax_spinner_load()\",\n \"def mark_refunded(self):\\n order = self.clone()\\n order.status = Order.STATUS_REFUNDED\\n order.save()\\n return order\",\n \"def status_update(request, id=None):\\n #obj = Todo.objects.all()\\n user = request.user if request.user.is_authenticated else None\\n Todo.objects.filter(id=id).update(mark_done=True, answered_by= user)\\n return redirect('lists:alllist')\",\n \"def order(self, id, long, qty, limit=0, stop=0, post_only=False, reduce_only=False, trailing_stop=0, activationPrice=0, when=True):\\n self.__init_client()\\n\\n # if self.get_margin()['excessMargin'] <= 0 or qty <= 0:\\n # return\\n\\n if not when:\\n return\\n\\n side = \\\"BUY\\\" if long else \\\"SELL\\\"\\n ord_qty = qty\\n\\n order = self.get_open_order(id)\\n ord_id = id + ord_suffix() #if order is None else order[\\\"clientOrderId\\\"]\\n\\n if order is None:\\n self.__new_order(ord_id, side, ord_qty, limit, stop, post_only, reduce_only, trailing_stop, activationPrice)\\n else:\\n self.__new_order(ord_id, side, ord_qty, limit, stop, post_only, reduce_only, trailing_stop, activationPrice)\\n #self.__amend_order(ord_id, side, ord_qty, limit, stop, post_only)\\n return\",\n \"def set_status(self, scenario_id, status):\\n self.cur.execute(\\n \\\"UPDATE execute_list SET status = %s WHERE id = %s\\\",\\n (status, scenario_id),\\n )\",\n \"def update_orders(comp, order, user_correct, payment_id):\\n users_orders = []\\n for item in order.items.all():\\n users_orders.append(item.id)\\n item.is_paid = True\\n item.save()\\n order.related_competition = comp\\n order.payment_id = payment_id\\n order.order_date = timezone.now()\\n order.answer_correct = user_correct\\n order.ordered = True\\n order.save()\\n return order\",\n \"def prepare_order(self, index, order_status):\\n if(self.running_qty > 0 and index > 0):\\n quantity = self.running_qty\\n price = self.get_price_offset3(index)\\n elif(self.running_qty < 0 and index < 0):\\n quantity = abs(self.running_qty)\\n price = self.get_price_offset3(index)\\n else:\\n quantity = self.ORDER_START_SIZE // 4\\n price = self.get_price_offset2(index)\\n if (price == None):\\n return None\\n else:\\n return {'price': price, 'orderQty': quantity, 'side': \\\"Buy\\\" if index < 0 else \\\"Sell\\\"}\",\n \"def test_an_order_can_be_edited(self):\\n\\n\\t\\tnew_data = {\\n\\t\\t\\t\\t\\t\\\"owner\\\": \\\"Pemwa\\\",\\n\\t\\t\\t\\t\\t\\\"meal_name\\\": \\\"Burger\\\",\\n\\t\\t\\t\\t\\t\\\"quantity\\\": 8\\n\\t\\t\\t\\t\\t }\\n\\n\\t\\tres = self.login_user()\\n\\t\\taccess_token = json.loads(res.data.decode())['access_token']\\n\\n\\t\\tresponse = self.client().post(\\n\\t\\t\\t'/api/v2/orders',\\n\\t\\t\\theaders={\\\"x-access-token\\\": access_token},\\n\\t\\t\\tdata = json.dumps(\\n\\t\\t\\t\\tself.order_data) , content_type = 'application/json')\\n\\t\\tself.assertEqual(response.status_code, 201)\\n\\n\\t\\tresponse = self.client().put(\\n\\t\\t\\t'/api/v2/orders/1',\\n\\t\\t\\theaders={\\\"x-access-token\\\": access_token},\\n\\t\\t\\tdata = json.dumps(\\n\\t\\t\\t\\tnew_data), content_type = 'application/json')\\n\\t\\tresult = json.loads(response.data)\\n\\t\\tself.assertEqual(response.status_code, 200)\",\n \"def mark_ready_for_review(self, user: User) -> None:\\n from .exceptions import OperationForbiddenError, OrderEmptyError\\n\\n # If order is not in the \\\"CREATED\\\" state, raise an\\n # OperationForbiddenError\\n if not self.is_created:\\n raise OperationForbiddenError(\\n self.STATE_CHANGE_FORBIDDEN_ERROR_MSG % {\\n 'current_state': Order.OrderState.get_choice_display(\\n self.state\\n ),\\n 'new_state': Order.OrderState.PENDING.choice_display\\n }\\n )\\n\\n # If the order's item list is empty, raise an OrderEmptyError\\n if not self.orderitem_set.exists():\\n raise OrderEmptyError(\\n self,\\n 'An order should contain at least one Order item before it '\\n 'can be marked as \\\"PENDING\\\".'\\n )\\n\\n # Update the order to \\\"PENDING\\\" state\\n self.update(user, state=Order.OrderState.PENDING.choice_value)\",\n \"def update_after_pick(self, item_id):\\n request_name = \\\"get_shop_info\\\"\\n items = self.make_request(request_name, url_id=item_id)\\n update_dict = dict()\\n for key in items[0]:\\n if str(key)[0] == \\\"_\\\":\\n continue\\n try:\\n update_dict[key.encode('utf-8')] = items[0][key].encode('utf-8')\\n except AttributeError:\\n update_dict[key.encode('utf-8')] = items[0][key]\\n\\n update_dict['quantity'] -= 1\\n resp = self.make_request('set_shop', url_id=item_id, arguments=update_dict)\",\n \"def test_change_order_status_when_order_does_not_exist(self):\\n response = self.api_test_client.put('{}/orders/1000'.format(\\n self.BASE_URL), json={'order_status': 'accepted'})\\n\\n self.assertEqual(response.status_code, 404)\\n self.assertEqual(response_as_json(\\n response)['message'],\\n 'Order with id 1000 not found')\",\n \"def set_status(trades, status):\\n acm.BeginTransaction()\\n try:\\n for trade in trades:\\n msg = \\\"Changing status on trade {0} ({1}) to {2}\\\"\\n print(msg.format(trade.Oid(), trade.Instrument().Name(), status))\\n trade.Status(status)\\n trade.Commit()\\n acm.CommitTransaction()\\n print(\\\"Statuses successfully changed\\\")\\n except Exception as ex:\\n print(\\\"Failed to change statuses on pswap trades: {0}\\\".format(ex))\\n acm.AbortTransaction()\",\n \"def purchase_item(self):\\r\\n self.purchased_callback()\\r\\n self.status = 'purchased'\\r\\n self.fulfilled_time = datetime.now(pytz.utc)\\r\\n self.save()\",\n \"def setComicStatus(self, handles, status):\\n db.execute(\\\"update comics set status=%s where handle in ('\\\" + \\\"', '\\\".join(handles) + \\\"')\\\", status)\",\n \"def update_order_state(self, orderid, new_state):\\n\\n cur.execute(\\\"\\\"\\\"UPDATE orders SET state = ? WHERE orderid = ?\\\"\\\"\\\",\\n (new_state, orderid))\",\n \"def setState(self, session, state_id, order_item_id=None, batch_id=None,\\n product_item_id=None):\\n orders = []\\n for wi in self.getWorkItems(session, order_item_id, \\n batch_id, product_item_id):\\n if batch_id is None and state_id == State.INPROGRESS and \\\\\\n self.activities.get(wi.activity_id)['entity_type'] == 'batch':\\n return self.setState(session, state_id, batch_id=wi.batch_id)\\n wi.state_id = state_id\\n orders.append(wi.order_item_id)\\n session.add(wi)\\n return orders\",\n \"def change_order(self, price, qty, orderid=0, envtype=0):\\n if not TRADE_CN.check_envtype_cn(envtype):\\n error_str = ERROR_STR_PREFIX + \\\"the type of environment param is wrong \\\"\\n return RET_ERROR, error_str\\n\\n query_processor = self._get_sync_query_processor(ChangeOrderCN.cn_pack_req,\\n ChangeOrderCN.cn_unpack_rsp)\\n\\n # the keys of kargs should be corresponding to the actual function arguments\\n kargs = {'cookie': str(self.cookie), 'envtype': str(envtype), 'localid': str(0),\\n 'orderid': str(orderid), 'price': str(price), 'qty': str(qty)}\\n\\n ret_code, msg, change_order_list = query_processor(**kargs)\\n if ret_code != RET_OK:\\n return RET_ERROR, msg\\n\\n col_list = ['envtype', 'orderID']\\n change_order_table = pd.DataFrame(change_order_list, columns=col_list)\\n\\n return RET_OK, change_order_table\",\n \"async def update(self, *args, **kwargs):\\n if not self.__bought:\\n random_stock = 1\\n stock_price = self.priceindicator[random_stock].price\\n if stock_price != 0:\\n random_const = float(decimal.Decimal(random.randrange(-5,5))/100)\\n stock_price = stock_price + stock_price*random_const\\n stock_price = int(stock_price)\\n await self.place_buy_order(random_stock, self.settings[\\\"stocks_per_company\\\"], stock_price, 1)\\n log_message = \\\"StockBuyerBot(\\\" + self.name + \\\") bought \\\" + str(random_stock)\\n print(log_message)\\n else:\\n log_message = \\\"StockBuyerBot(\\\" + self.name + \\\") bought nothing\\\"\\n print(log_message)\\n self.add_to_log(self.id, log_message)\",\n \"def update_request_status(self, requestID, ISBN, quantity, approved):\\n if approved:\\n self.cursor.execute(\\\"\\\"\\\"SELECT orderNumber FROM returnrequest WHERE requestID=%s\\\"\\\"\\\", (requestID,))\\n orderNumber = self.cursor.fetchone()[0]\\n self.cursor.execute(\\\"\\\"\\\"UPDATE returnrequest SET status='APPROVED' WHERE requestID=%s\\\"\\\"\\\", (requestID,))\\n self.cursor.execute(\\\"\\\"\\\"SELECT quantity FROM productof WHERE orderNumber=%s AND ISBN=%s\\\"\\\"\\\",\\n (orderNumber, ISBN))\\n remaining_books_ordered = self.cursor.fetchone()[0] - int(quantity)\\n if not int(remaining_books_ordered):\\n self.cursor.execute(\\\"\\\"\\\"DELETE FROM productof WHERE orderNumber=%s AND ISBN=%s\\\"\\\"\\\", (orderNumber, ISBN))\\n else:\\n self.cursor.execute(\\\"\\\"\\\"UPDATE productof SET quantity=quantity-%s WHERE orderNumber=%s AND ISBN=%s\\\"\\\"\\\",\\n (quantity, orderNumber, ISBN))\\n self.cursor.execute(\\\"\\\"\\\"UPDATE book SET stock=stock+%s WHERE ISBN=%s\\\"\\\"\\\", (quantity, ISBN))\\n self.db.commit()\\n if self.is_empty_order(orderNumber):\\n self.cursor.execute(\\\"\\\"\\\"DELETE FROM orderlog WHERE orderNumber=%s\\\"\\\"\\\", (orderNumber,))\\n else:\\n self.cursor.execute(\\\"\\\"\\\"UPDATE returnrequest SET status='DENIED' WHERE requestID=%s\\\"\\\"\\\", (requestID,))\\n self.db.commit()\",\n \"def kitchenConfirm(self, id, eta=0):\\n if(eta == 0):\\n json = None\\n else: \\n json = {\\\"eta\\\": eta}\\n return self.__insertOrderHistory(id, \\\"kitchenConfirmed\\\", json)\",\n \"def food_selected(self, arg):\\n\\t\\tfood = fooditemdao.retrieve_food(self.selected_food.get())\\n\\t\\tself.lbl_unit.config(text=food.info['unit'])\",\n \"def change_oakhaven_pswap_trades(status):\\n print(\\\"Processing pswaps for OAKHAVEN\\\")\\n portfolio = acm.FPhysicalPortfolio[\\\"PB_PSWAP_OAKHAVEN_CR\\\"]\\n trades = [t for t in portfolio.Trades() if \\\"OLD\\\" in t.Instrument().Name()]\\n set_status(trades, status)\",\n \"def updatestatus(id, status):\\n username = os.getlogin()\\n res = requests.put('{}update/{}/'.format(base_url, id),\\n data={\\\"keyword_fetching_status\\\": status, \\\"user_fetched\\\": username})\\n res = res.json()\\n return res\",\n \"def ord_status(self, uid):\\n # TODO: use ticker to select market orderbook\\n return self.mkt.get(uid)\",\n \"def _act_task_checked(self, iden, b):\\n if b:\\n self.data.turn_on(iden)\\n else:\\n self.data.turn_off()\",\n \"def test_update_an_order(self):\\n order = PizzaOrder.objects.get(id=self.response.data['id'])\\n updated_order = {\\\"customer\\\": {\\n \\\"first_name\\\": \\\"Lara\\\",\\n \\\"last_name\\\": \\\"Tanbari\\\",\\n \\\"address\\\": \\\"Coppistr22, 10365 Berlin\\\"\\n },\\n \\\"size\\\": \\\"SMALL\\\"\\n }\\n res = self.client.put(\\n reverse('order_details',\\n kwargs={'order_id': order.id}),\\n updated_order,\\n format='json'\\n )\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\",\n \"def _set_status(self):\\n result = self._get_status()\\n if result and result[0]['state'] == 'aborted':\\n raise Exception(\\\"Aborted because the status flag is set to 'aborted' in dynamodb\\\")\\n\\n # record the status\\n self.status['timestamp'] = time.strftime(\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n self.db_handler.update_item({'api_version': TsV2CatalogHandler.api_version}, self.status)\",\n \"def mark_completed(self,status):\\r\\n if status == \\\"r\\\":\\r\\n self.status = \\\"c\\\"#It is to test the mark complete function in the test_book.py, otherwise this program works fine in the main.py\\r\\n return True\\r\\n elif status == \\\"c\\\":\\r\\n return False\",\n \"def set_cancelled_order(self):\\n self.set_values(\\n start_phrase='Cancelled Orders',\\n end_phrase=None,\\n start_with=2,\\n end_until=-1,\\n prop_keys=self.cancelled_order_keys,\\n prop_name='cancelled_order'\\n )\\n\\n self.cancelled_order = map(self.del_empty_keys, self.cancelled_order)\\n self.fillna_dict_with_exists(\\n self.cancelled_order,\\n 'time_cancelled',\\n ('time_cancelled', 'spread', 'order', 'tif', 'status')\\n )\\n self.replace_nan(self.cancelled_order)\\n\\n self.convert_type(self.cancelled_order, 'time_cancelled', self.convert_datetime, 0)\\n self.convert_type(self.cancelled_order, 'quantity', int, 0)\\n self.convert_type(self.cancelled_order, 'strike', float, 0.0)\\n self.convert_type(self.cancelled_order, 'price', float, 0.0)\\n self.convert_type(self.cancelled_order, 'expire_date', str, '')\",\n \"def id_status(self, id_status):\\n self._id_status = id_status\",\n \"def onCancelOrder(self, item):\\n self.frame.mode.cancelIndustryOrder(self.lstOrders.getMultiSelectedItems(), self.mySystemDict['id'])\",\n \"def switch():\\n\\n if request.method == 'POST':\\n id = request.args['id']\\n\\n cur = db.get_db().cursor()\\n\\n cur.execute(\\n 'UPDATE todos SET completed=(%s)'\\n 'WHERE id = (%s)',\\n ('True', id))\\n\\n g.db.commit()\\n\\n cur.close()\\n\\n return redirect(url_for('todos.index'))\",\n \"def update_status(request_id, status):\\n pass\",\n \"def kitchenComplete(self, id):\\n return self.__insertOrderHistory(id, \\\"kitchenComplete\\\", {})\",\n \"def settle_self(self):\\n self.state = 'completed'\\n self.save()\\n self.safe_post()\",\n \"def slot_user_order(self, dummy_sender, data):\\r\\n (price, volume, typ, oid, status) = data\\r\\n found = False\\r\\n removed = False # was the order removed?\\r\\n opened = False # did the order change from 'post-pending' to 'open'\\\"?\\r\\n voldiff = 0 # did the order volume change (full or partial fill)\\r\\n if \\\"executing\\\" in status:\\r\\n # don't need this status at all\\r\\n return\\r\\n if \\\"post-pending\\\" in status:\\r\\n # don't need this status at all\\r\\n return\\r\\n if \\\"removed\\\" in status:\\r\\n for i in range(len(self.owns)):\\r\\n if self.owns[i].oid == oid:\\r\\n order = self.owns[i]\\r\\n\\r\\n # work around MtGox strangeness:\\r\\n # for some reason it will send a \\\"completed_passive\\\"\\r\\n # immediately followed by a \\\"completed_active\\\" when a\\r\\n # market order is filled and removed. Since \\\"completed_passive\\\"\\r\\n # is meant for limit orders only we will just completely\\r\\n # IGNORE all \\\"completed_passive\\\" if it affects a market order,\\r\\n # there WILL follow a \\\"completed_active\\\" immediately after.\\r\\n if order.price == 0:\\r\\n if \\\"passive\\\" in status:\\r\\n # ignore it, the correct one with\\r\\n # \\\"active\\\" will follow soon\\r\\n return\\r\\n\\r\\n self.debug(\\r\\n \\\"### removing order %s \\\" % oid,\\r\\n \\\"price:\\\", self.gox.quote2str(order.price),\\r\\n \\\"type:\\\", order.typ)\\r\\n\\r\\n # remove it from owns...\\r\\n self.owns.pop(i)\\r\\n\\r\\n # ...and update own volume cache in the bids or asks\\r\\n self._update_level_own_volume(\\r\\n order.typ,\\r\\n order.price,\\r\\n self.get_own_volume_at(order.price, order.typ)\\r\\n )\\r\\n removed = True\\r\\n break\\r\\n else:\\r\\n for order in self.owns:\\r\\n if order.oid == oid:\\r\\n found = True\\r\\n self.debug(\\r\\n \\\"### updating order %s \\\" % oid,\\r\\n \\\"volume:\\\", self.gox.base2str(volume),\\r\\n \\\"status:\\\", status)\\r\\n voldiff = volume - order.volume\\r\\n opened = (order.status != \\\"open\\\" and status == \\\"open\\\")\\r\\n order.volume = volume\\r\\n order.status = status\\r\\n break\\r\\n\\r\\n if not found:\\r\\n # This can happen if we added the order with a different\\r\\n # application or the gox server sent the user_order message\\r\\n # before the reply to \\\"order/add\\\" (this can happen because\\r\\n # actually there is no guarantee which one arrives first).\\r\\n # We will treat this like a reply to \\\"order/add\\\"\\r\\n self.add_own(Order(price, volume, typ, oid, status))\\r\\n\\r\\n # The add_own() method has handled everything that was needed\\r\\n # for new orders and also emitted all signals already, we\\r\\n # can immediately return here because the job is done.\\r\\n return\\r\\n\\r\\n # update level own volume cache\\r\\n self._update_level_own_volume(\\r\\n typ, price, self.get_own_volume_at(price, typ))\\r\\n\\r\\n # We try to help the strategy with tracking the orders as good\\r\\n # as we can by sending different signals for different events.\\r\\n if removed:\\r\\n reason = self.gox.msg[\\\"user_order\\\"][\\\"reason\\\"]\\r\\n self.signal_own_removed(self, (order, reason))\\r\\n if opened:\\r\\n self.signal_own_opened(self, (order))\\r\\n if voldiff:\\r\\n self.signal_own_volume(self, (order, voldiff))\\r\\n self.signal_changed(self, None)\\r\\n self.signal_owns_changed(self, None)\",\n \"def change_status(self):\\n if self.status == 'in progress':\\n self.status = 'done'\\n return self.status\\n elif self.status == 'done':\\n self.status = 'in progress'\\n self.eisenhower_priority()\\n return self.status\",\n \"def onOrderSelected(self, item):\\n if self.lstOrders.getMultiSelectedItems() == []:\\n self.btnCancelOrder.disable()\\n else:\\n self.enableButtons(self.lstOrders, [self.btnCancelOrder])\",\n \"def triggerPrintOrderStatus(self, prompt):\\n if prompt is not None:\\n split_prompt = prompt.split(':')\\n truck_id = int(split_prompt[1].lstrip())\\n print(f'The following status of {truck_id} orders:')\\n self._printOrderStatus(truck_id)\",\n \"async def update_trade_status():\\n # GET /api/v3/openOrders - get current open orders\\n # GET /api/v3/allOrders - get all orders: active, canceled, or filled\\n\\n symbol = App.config[\\\"symbol\\\"]\\n\\n # -----\\n try:\\n open_orders = App.client.get_open_orders(symbol=symbol) # By \\\"open\\\" orders they probably mean \\\"NEW\\\" or \\\"PARTIALLY_FILLED\\\"\\n # orders = App.client.get_all_orders(symbol=symbol, limit=10)\\n except Exception as e:\\n log.error(f\\\"Binance exception in 'get_open_orders' {e}\\\")\\n return\\n\\n if not open_orders:\\n # -----\\n await update_account_balance()\\n\\n last_kline = App.analyzer.get_last_kline(symbol)\\n last_close_price = to_decimal(last_kline[4]) # Close price of kline has index 4 in the list\\n\\n base_quantity = App.base_quantity # BTC\\n btc_assets_in_usd = base_quantity * last_close_price # Cost of available BTC in USD\\n\\n usd_assets = App.quote_quantity # USD\\n\\n if usd_assets >= btc_assets_in_usd:\\n App.status = \\\"SOLD\\\"\\n else:\\n App.status = \\\"BOUGHT\\\"\\n\\n elif len(open_orders) == 1:\\n order = open_orders[0]\\n if order.get(\\\"side\\\") == SIDE_SELL:\\n App.status = \\\"SELLING\\\"\\n elif order.get(\\\"side\\\") == SIDE_BUY:\\n App.status = \\\"BUYING\\\"\\n else:\\n log.error(f\\\"Neither SELL nor BUY side of the order {order}.\\\")\\n return None\\n\\n else: # Many orders\\n log.error(f\\\"Wrong state. More than one open order. Fix manually.\\\")\\n return None\",\n \"def completed(request):\\n order_id = ''\\n try:\\n order_id = request.session['order_id']\\n except:\\n pass\\n if order_id != '':\\n auth = HTTPBasicAuth(klarna_un, klarna_pw)\\n headers = {'content-type': 'application/json'}\\n response = requests.get(\\n settings.KLARNA_BASE_URL + '/checkout/v3/orders/' +\\n order_id,\\n auth=auth,\\n headers=headers,\\n )\\n klarna_order = response.json()\\n order = Order(\\n order_id=klarna_order['order_id'],\\n status=klarna_order['status'],\\n given_name=klarna_order['billing_address']['given_name'],\\n family_name=klarna_order['billing_address']['family_name'],\\n email=klarna_order['billing_address']['email'],\\n phone_number=klarna_order['billing_address']['phone'],\\n country=klarna_order['billing_address']['country'],\\n postcode=klarna_order['billing_address']['postal_code'],\\n town_or_city=klarna_order['billing_address']['city'],\\n street_address1=klarna_order['billing_address']['street_address'],\\n order_total=klarna_order['order_amount'],\\n klarna_line_items=klarna_order['order_lines']\\n )\\n order.save()\\n request.session['cart'] = {}\\n request.session['order_id'] = ''\\n \\n context = {\\n 'klarna_order': klarna_order\\n }\\n\\n return render(request, 'checkout/completed.html', context)\\n else:\\n return redirect(reverse(view_cart))\",\n \"def set_vendor_price_list_status(self, status_items):\\n self.multiple_items_selection_from_kendo_dropdown(self.vendor_price_list_status_kendo_dropdown_locator, status_items)\\n self.wait_for_ajax_spinner_load()\",\n \"async def on_order_completed(self, order_id: str):\\n self._orders = list(filter(lambda order: order['id'] != order_id, self._orders))\",\n \"def checkout(request):\\n\\n\\n auth = HTTPBasicAuth(klarna_un, klarna_pw)\\n headers = {'content-type': 'application/json'}\\n cart = request.session.get('cart')\\n total = 0\\n orderlines = []\\n order_id = 0\\n try:\\n order_id = request.session['order_id']\\n except:\\n pass\\n for item in cart:\\n product = utils.get_product(item)\\n orderlines.append({\\n 'name': product[1].name,\\n 'reference': product[1].id,\\n 'unit_price': int(product[1].price * 100),\\n 'quantity': int(cart[item]),\\n 'tax_rate': int(00),\\n 'total_amount': int(product[1].price * cart[item] * 100),\\n \\\"total_tax_amount\\\": 0\\n })\\n total += product[1].price * cart[item] * 100\\n integer_total = int(total)\\n if order_id:\\n response = requests.get(\\n settings.KLARNA_BASE_URL + '/checkout/v3/orders/' +\\n order_id,\\n auth=auth,\\n headers=headers,\\n )\\n\\n klarna_order = response.json()\\n if klarna_order['order_lines'] == orderlines:\\n context = {\\n 'klarna_order': klarna_order\\n\\n }\\n return render(request, 'checkout/checkout.html', context)\\n else:\\n body = {\\n \\\"purchase_country\\\": \\\"se\\\",\\n \\\"purchase_currency\\\": \\\"eur\\\",\\n \\\"locale\\\": \\\"en-GB\\\",\\n \\\"order_amount\\\": integer_total,\\n \\\"order_tax_amount\\\": 0,\\n \\\"order_lines\\\": orderlines,\\n \\\"merchant_urls\\\": {\\n \\\"terms\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/terms\\\",\\n \\\"checkout\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/completed\\\",\\n \\\"confirmation\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/completed\\\",\\n \\\"push\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/orders/register_order?sid={checkout.order.id}\\\"\\n },\\n \\\"shipping_options\\\": [\\n {\\n \\\"id\\\": \\\"free_shipping\\\",\\n \\\"name\\\": \\\"Free Shipping\\\",\\n \\\"description\\\": \\\"Delivers in 5-7 days\\\",\\n \\\"price\\\": 0,\\n \\\"tax_amount\\\": 0,\\n \\\"tax_rate\\\": 0,\\n \\\"preselected\\\": True,\\n \\\"shipping_method\\\": \\\"Home\\\"\\n },\\n {\\n \\\"id\\\": \\\"pick_up_store\\\",\\n \\\"name\\\": \\\"Pick up at closest store\\\",\\n \\\"price\\\": 399,\\n \\\"tax_amount\\\": 0,\\n \\\"tax_rate\\\": 0,\\n \\\"preselected\\\": False,\\n \\\"shipping_method\\\": \\\"PickUpStore\\\"\\n }\\n ]\\n }\\n data = json.dumps(body)\\n response = requests.post(\\n settings.KLARNA_BASE_URL + '/checkout/v3/orders/' +\\n order_id,\\n auth=auth,\\n headers=headers,\\n data=data)\\n\\n klarna_order = response.json()\\n context = {\\n 'klarna_order': klarna_order\\n }\\n return render(request, 'checkout/checkout.html', context)\\n else:\\n cart = request.session.get('cart')\\n total = 0\\n orderlines = []\\n for item in cart:\\n product = utils.get_product(item)\\n orderlines.append({\\n 'name': product[1].name,\\n 'product_id': product[1].id,\\n 'unit_price': int(product[1].price * 100),\\n 'quantity': int(cart[item]),\\n 'tax_rate': int(00),\\n 'total_amount': int(product[1].price * cart[item] * 100),\\n \\\"total_tax_amount\\\": 0\\n\\n })\\n total += product[1].price * cart[item] * 100\\n\\n integer_total = int(total)\\n body = {\\n \\\"purchase_country\\\": \\\"se\\\",\\n \\\"purchase_currency\\\": \\\"eur\\\",\\n \\\"locale\\\": \\\"en-GB\\\",\\n \\\"order_amount\\\": integer_total,\\n \\\"order_tax_amount\\\": 0,\\n \\\"order_lines\\\": orderlines,\\n \\\"merchant_urls\\\": {\\n \\\"terms\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/terms\\\",\\n \\\"checkout\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/completed\\\",\\n \\\"confirmation\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/checkout/completed\\\",\\n \\\"push\\\": \\\"https://beerbrewing-supply.herokuapp.com\\\" + \\\"/orders/register_order?sid={checkout.order.id}\\\"\\n },\\n \\\"shipping_options\\\": [\\n {\\n \\\"id\\\": \\\"free_shipping\\\",\\n \\\"name\\\": \\\"Free Shipping\\\",\\n \\\"description\\\": \\\"Delivers in 5-7 days\\\",\\n \\\"price\\\": 0,\\n \\\"tax_amount\\\": 0,\\n \\\"tax_rate\\\": 0,\\n \\\"preselected\\\": True,\\n \\\"shipping_method\\\": \\\"Home\\\"\\n },\\n {\\n \\\"id\\\": \\\"pick_up_store\\\",\\n \\\"name\\\": \\\"Pick up at closest store\\\",\\n \\\"price\\\": 399,\\n \\\"tax_amount\\\": 0,\\n \\\"tax_rate\\\": 0,\\n \\\"preselected\\\": False,\\n \\\"shipping_method\\\": \\\"PickUpStore\\\"\\n }\\n ]\\n }\\n data = json.dumps(body)\\n response = requests.post(\\n settings.KLARNA_BASE_URL + '/checkout/v3/orders',\\n auth=auth,\\n headers=headers,\\n data=data)\\n\\n klarna_order = response.json()\\n context = {\\n 'klarna_order': klarna_order\\n\\n }\\n order_id = klarna_order['order_id']\\n request.session['order_id'] = order_id\\n\\n return render(request, 'checkout/checkout.html', context)\",\n \"def checked_classified(self, order):\\n assert (order.get_status() is OrderStatus.Created)\\n assert (order.direction is not Direction.Cancel)\\n if order.exec_type not in [Exectype.Market, Exectype.Stop]:\\n assert (order.price is not None)\\n check_left = np.round(order.price / self.table.tick_size, self.tick_size_decimals)\\n check_right = np.round(order.price / self.table.tick_size, self.tick_size_decimals)\\n assert check_left == check_right\\n # Check expiration\\n order = self.checked_expired(order)\\n if order.get_status() is OrderStatus.Expired:\\n self.debug(\\\"Order expired: order.reject()\\\")\\n order.reject(self.table.get_current_time())\\n else:\\n if not self.table.allow_duplicated_ids and order.m_orderId in self.queue_observer.get_order_ids():\\n self.debug(\\\"Order implies duplicated id: order.reject()\\\")\\n order.reject(self.table.get_current_time())\\n else:\\n self.debug(\\\"Order can be accepted: order.accept()\\\")\\n order.accept(self.table.get_current_time())\\n return order\",\n \"def order_w_order_id(order_id):\\n # Megnyutjuk a kapcsolatot\\n conn = get_db()\\n try:\\n # Keszitunk egy cursort\\n cur = conn.cursor()\\n try:\\n # Ezt a parameteres SQL lekerdezest hajtjuk vegre, mellyel megkapjuk az adott\\n # order_id-ju megrendelest.\\n cur.execute('SELECT description, vehicle_type, quantity, origin, destination,' +\\n ' order_date, deadline_date, comment_text FROM orders WHERE' +\\n ' order_id = :order_id', order_id=order_id)\\n # Ebben a valtozoban lesz az eredmenytabla egyetlen\\n # sora (Biztosan 1 lesz, mert az order_id egyedi)\\n result = cur.fetchone()\\n # Ha nem talaltunk ilyen megrendelest, szolunk a felhasznalonak\\n if result is None:\\n abort(404)\\n else:\\n # 2. feladat - lekerdezzuk az adott orszag valutajat\\n #\\n # Az origin illetve destination mezokben megkeressuk az orszag betujelet\\n # Ez mindig a string vegen, ( es ) jelek kozott allo 2 betu.\\n # Mivel ezek nagybetuvel irodtak at kell konvertalnunk kisbeture.\\n # Ezek futtatjuk a kerest, majd a kapott eredmenyt JSON formatumra parsoljuk.\\n # Ebbol kiolvassuk a valuta erteket, amit majd atadunk a kimeneti mezonknek.\\n origin001 = result[3]\\n origin_len = len(origin001)\\n origin_tmp = origin001[origin_len-3:origin_len-1]\\n origin_url = \\\"http://rapid.eik.bme.hu:9080/currency_ws/currencies/\\\" + origin_tmp.lower() + \\\".json\\\"\\n r1 = requests.get(origin_url)\\n var1 = r1.json()\\n origin_currency = var1['currency']\\n \\n destination001 = result[4]\\n destination_len = len(destination001)\\n destination_tmp = destination001[destination_len-3:destination_len-1]\\n destination_url = \\\"http://rapid.eik.bme.hu:9080/currency_ws/currencies/\\\" + destination_tmp.lower() + \\\".json\\\"\\n r2 = requests.get(destination_url)\\n var2 = r2.json()\\n destination_currency = var2['currency']\\n # Visszaterunk a JSON formatumu dictionary-vel,\\n # ami mindent a megfelelo formatumban tarol\\n return jsonify({\\\"description\\\": result[0],\\n \\\"vehicle_type\\\": result[1],\\n \\\"quantity\\\": result[2],\\n \\\"origin\\\": result[3],\\n \\\"destination\\\": result[4],\\n \\\"order_date\\\": result[5].date().isoformat(),\\n \\\"deadline_date\\\": result[6].date().isoformat(),\\n \\\"comment_text\\\": result[7],\\n \\\"origin_currency\\\": origin_currency,\\n\\\"destination_currency\\\": destination_currency})\\n finally:\\n cur.close()\\n finally:\\n conn.close()\",\n \"def cancel_a_parcel(id):\\n query = \\\"\\\"\\\"UPDATE parcels SET status = %s WHERE id = %s\\\"\\\"\\\"\\n tuple =('canceled' , id)\\n db.insert(query, tuple)\",\n \"def on_trade_order_check(self, orderid, envtype, status):\\n if is_cntrade_order_status_finish(status):\\n self._obj_order_sub.del_val(orderid=orderid, envtype=envtype)\\n elif (not self._obj_order_sub.has_val(orderid, envtype)) and self._obj_order_sub.has_val(u'', envtype):\\n self._obj_order_sub.add_val(orderid, envtype) # record info for subscribe order u''\",\n \"def order_id(self, order_id):\\n\\n self._order_id = order_id\",\n \"def order_id(self, order_id):\\n\\n self._order_id = order_id\",\n \"def order_id(self, order_id):\\n\\n self._order_id = order_id\",\n \"def anche_cliente(self, request, pk=None):\\n fornitore = get_object_or_404(Entita, pk=pk)\\n fornitore.is_client = True\\n fornitore.save()\\n serializer = ClienteSerializer(fornitore)\\n return Response(serializer.data, status=status.HTTP_200_OK)\",\n \"def activate(self, id):\\n self.db.commit([\\n 'UPDATE comments SET',\\n ' mode=1',\\n 'WHERE id=%s AND mode=2'], (id, ))\",\n \"async def on_order_updated(self, order: MetatraderOrder):\\n for i in range(len(self._orders)):\\n if self._orders[i]['id'] == order['id']:\\n self._orders[i] = order\\n break\\n else:\\n self._orders.append(order)\",\n \"def id_status_conta(self, id_status_conta):\\n self._id_status_conta = id_status_conta\",\n \"def _update_status(self):\\n self._db_update({'status': self.status})\",\n \"def descricao_status_cartao(self, descricao_status_cartao):\\n self._descricao_status_cartao = descricao_status_cartao\",\n \"def update_order(request):\\n order = request.session.get('order', {})\\n quantity = int(request.POST.get('quantity'))\\n sizeID = str(request.POST.get('sizeID'))\\n colorID = str(request.POST.get('colorID'))\\n productID = str(request.POST.get('productID'))\\n order_item_identifier = productID + \\\" \\\" + colorID + \\\" \\\" + sizeID\\n if quantity > 0:\\n order[order_item_identifier] = quantity\\n print(str(order_item_identifier))\\n else:\\n order.pop(order_item_identifier)\\n request.session['order'] = order\\n return redirect(reverse('orders'))\",\n \"def set_status(self, status):\\n # TODO log to db\\n self.status = status\",\n \"def make_active(self, request, queryset):\\n queryset.update(is_active=True)\",\n \"def set_status(self, status):\\n self.status = status\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63635933","0.586669","0.5858225","0.58000624","0.56946445","0.5581705","0.55623066","0.55381656","0.5464021","0.5398148","0.53747994","0.5373412","0.53628695","0.5324506","0.5319295","0.52873236","0.5282698","0.52594453","0.5258599","0.52334434","0.52323323","0.52323323","0.5220004","0.52061313","0.5198367","0.51858896","0.51746446","0.51692444","0.51510894","0.51437265","0.514347","0.5140636","0.50827116","0.50657225","0.5064627","0.50352085","0.50342745","0.5026687","0.501803","0.49929836","0.49858505","0.49701184","0.4938751","0.49357566","0.4928911","0.4917222","0.49070767","0.490578","0.4902955","0.4893624","0.48909044","0.48822966","0.48702443","0.4867332","0.48661292","0.484832","0.48281193","0.48269013","0.4826091","0.48227748","0.48210022","0.4811911","0.48023936","0.4793385","0.4788168","0.47870874","0.47841012","0.47823602","0.47782773","0.47704098","0.47678402","0.47604176","0.4757403","0.47571447","0.47550118","0.47519714","0.47500423","0.4749633","0.4743691","0.4740933","0.47385022","0.47365662","0.47360435","0.4734022","0.47211516","0.47147587","0.47146857","0.47130507","0.47130507","0.47130507","0.4709882","0.47089073","0.47084042","0.47025263","0.47005513","0.46946785","0.4689134","0.46858037","0.4684825","0.46612138"],"string":"[\n \"0.63635933\",\n \"0.586669\",\n \"0.5858225\",\n \"0.58000624\",\n \"0.56946445\",\n \"0.5581705\",\n \"0.55623066\",\n \"0.55381656\",\n \"0.5464021\",\n \"0.5398148\",\n \"0.53747994\",\n \"0.5373412\",\n \"0.53628695\",\n \"0.5324506\",\n \"0.5319295\",\n \"0.52873236\",\n \"0.5282698\",\n \"0.52594453\",\n \"0.5258599\",\n \"0.52334434\",\n \"0.52323323\",\n \"0.52323323\",\n \"0.5220004\",\n \"0.52061313\",\n \"0.5198367\",\n \"0.51858896\",\n \"0.51746446\",\n \"0.51692444\",\n \"0.51510894\",\n \"0.51437265\",\n \"0.514347\",\n \"0.5140636\",\n \"0.50827116\",\n \"0.50657225\",\n \"0.5064627\",\n \"0.50352085\",\n \"0.50342745\",\n \"0.5026687\",\n \"0.501803\",\n \"0.49929836\",\n \"0.49858505\",\n \"0.49701184\",\n \"0.4938751\",\n \"0.49357566\",\n \"0.4928911\",\n \"0.4917222\",\n \"0.49070767\",\n \"0.490578\",\n \"0.4902955\",\n \"0.4893624\",\n \"0.48909044\",\n \"0.48822966\",\n \"0.48702443\",\n \"0.4867332\",\n \"0.48661292\",\n \"0.484832\",\n \"0.48281193\",\n \"0.48269013\",\n \"0.4826091\",\n \"0.48227748\",\n \"0.48210022\",\n \"0.4811911\",\n \"0.48023936\",\n \"0.4793385\",\n \"0.4788168\",\n \"0.47870874\",\n \"0.47841012\",\n \"0.47823602\",\n \"0.47782773\",\n \"0.47704098\",\n \"0.47678402\",\n \"0.47604176\",\n \"0.4757403\",\n \"0.47571447\",\n \"0.47550118\",\n \"0.47519714\",\n \"0.47500423\",\n \"0.4749633\",\n \"0.4743691\",\n \"0.4740933\",\n \"0.47385022\",\n \"0.47365662\",\n \"0.47360435\",\n \"0.4734022\",\n \"0.47211516\",\n \"0.47147587\",\n \"0.47146857\",\n \"0.47130507\",\n \"0.47130507\",\n \"0.47130507\",\n \"0.4709882\",\n \"0.47089073\",\n \"0.47084042\",\n \"0.47025263\",\n \"0.47005513\",\n \"0.46946785\",\n \"0.4689134\",\n \"0.46858037\",\n \"0.4684825\",\n \"0.46612138\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7182565"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4193,"cells":{"query":{"kind":"string","value":"chang the order's status to be \"readytoserve\" which is selected by the id of order"},"document":{"kind":"string","value":"def order_ready(request):\n\tcs , status = CookStatus.objects.get_or_create(cook_name=request.user)\n\tif cs.current_order is not None:\n\t\tcs.current_order.status = 'ready-to-serve'\n\t\tcs.current_order.save()\n\t\tcs.current_order = None\n\t\tcs.save()\n\n\treturn HttpResponseRedirect(\"/staff/cook_order_list/\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def update_order_status():\n symbol = App.config[\"symbol\"]\n\n # Get currently active order and id (if any)\n order = App.order\n order_id = order.get(\"orderId\", 0) if order else 0\n if not order_id:\n log.error(f\"Wrong state or use: check order status cannot find the order id.\")\n return None\n\n # -----\n # Retrieve order from the server\n try:\n new_order = App.client.get_order(symbol=symbol, orderId=order_id)\n except Exception as e:\n log.error(f\"Binance exception in 'get_order' {e}\")\n return\n\n # Impose and overwrite the new order information\n if new_order:\n order.update(new_order)\n else:\n return None\n\n # Now order[\"status\"] contains the latest status of the order\n return order[\"status\"]","def order_update_status():\n result = order_obj.order_update_status(request.forms) \n return result","def api_mark_order_ready(request, id):\n\n close_old_connections()\n \n # Not marking it as served if it isn't even ready yet.\n if not request.user.is_authenticated:\n return HttpResponseForbidden(\"You're not authenticated.\")\n \n # Get the order.\n order = Order.objects.get(id=id)\n \n # Mark the order as served and save it.\n order.ready = not order.ready\n order.save()\n\n close_old_connections()\n\n return HttpResponse('Marked as ready')","def update_specific_order(self,status,order_id):\n self.query = \"UPDATE orders SET order_status=%s WHERE order_id=%s\"\n self.input = (status,order_id) #tuple to support indexing\n self.query_1 = \"SELECT order_id FROM orders ORDER BY order_id DESC LIMIT 1.\"\n self.query_2 = \"SELECT * FROM orders WHERE order_id=%s\"\n self.input_2 = (order_id,) #tuple to support indexing\n self.event = \"admin_update_specific_order\"\n self.error = \"Invalid order id\"\n self.message = \"Successfully updated the order.\"\n self.order_id = order_id\n self.db_error = None","def mark_completed(self, order_id=None):\n self.status = \"paid\"\n if order_id and not self.order_id:\n self.order_id = order_id\n print(\"Order completed\")\n self.save()","def change_status(id):\n query = \"\"\"UPDATE parcels SET status = %s WHERE id = %s\"\"\"\n tuple =('delivered' , id)\n db.insert(query, tuple)","def status(self, id):","def test_manager_change_order_status(self):\n self.client.force_authenticate(self.user)\n cancel = \"CA\"\n url = reverse('order-set_status', args=[self.order.id])\n resp = self.client.patch(url, data={\n \"status\": cancel\n })\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n new_status = Order.objects.values(\"status\").get(pk=self.order.id)\n self.assertEqual(new_status[\"status\"], cancel)\n\n with self.subTest('customer can not change order status'):\n self.user.role = get_user_model().CUSTOMER\n self.client.force_authenticate(self.user)\n resp = self.client.patch(url, data={\n \"status\": cancel\n })\n self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)","def test_update_order(self):\n response = self.api_test_client.put('{}/orders/1'.format(\n self.BASE_URL), json={'order_status': 'accepted'})\n\n self.assertEqual(response.status_code, 201)\n self.assertTrue(\n response_as_json(response)['order']['status_updated_on'])\n self.assertEqual(\n response_as_json(response)['order']['order_status'], 'accepted')","def update_order(self, order):\n order.order_id = self.order_id\n order.average_price = self.avg_execution_price\n order.symbol = self.symbol\n order.side = self.side\n order.type = self.order_type\n order.amount = self.original_amount\n order.price = self.price\n order.filled = self.executed_amount\n order.remaining = self.remaining_amount\n if self.is_cancelled:\n order.status = exchanges.Order.Status.CANCELLED\n elif self.is_live:\n order.status = exchanges.Order.Status.OPEN\n else:\n order.status = exchanges.Order.Status.CLOSED\n return order","def set_add_dispute_status(self, status):\n self.single_selection_from_kendo_dropdown(self.add_dispute_status_kendo_dropdown_locator, status)\n self.wait_for_ajax_spinner_load()","def test_admin_change_order_status(self):\n # Test unregistered id\n # Correct format but not there\n response = self.client.put(\n 'api/v1/parcels/35420', headers=self.admin_token_dict)\n data = json.loads(response.data)\n self.assertEqual(response.status_code, 400)\n self.assertEqual(\n data, {'message': 'No Parcel delivery order with that id'})\n # Test invalid format id\n response = self.client.put(\n 'api/v1/parcels/35uh420', headers=self.admin_token_dict) # Incorrect id format\n data = json.loads(response.data)\n self.assertEqual(response.status_code, 400)\n self.assertEqual(data, {'message': 'Wrong id format'})","def put(self):\n request_data = json.loads(request.data)\n print(request_data)\n order_id = request_data['order_id']\n status = request_data['status']\n MM.update_order_status(ObjectId(order_id), status)\n return {\"message\": \"Order Status Updated\"}, 200","def set_order_status(self, status, orderid=0, envtype=0):\n if int(status) not in TRADE_CN.REV_ORDER_STATUS:\n error_str = ERROR_STR_PREFIX + \"the type of status is wrong \"\n return RET_ERROR, error_str\n\n if not TRADE_CN.check_envtype_cn(envtype):\n error_str = ERROR_STR_PREFIX + \"the type of environment param is wrong \"\n return RET_ERROR, error_str\n\n query_processor = self._get_sync_query_processor(SetOrderStatusCN.cn_pack_req,\n SetOrderStatusCN.cn_unpack_rsp)\n\n # the keys of kargs should be corresponding to the actual function arguments\n kargs = {'cookie': str(self.cookie), 'envtype': str(envtype), 'localid': str(0),\n 'orderid': str(orderid), 'status': str(status)}\n\n ret_code, msg, set_order_list = query_processor(**kargs)\n if ret_code != RET_OK:\n return RET_ERROR, msg\n\n col_list = ['envtype', 'orderID']\n set_order_table = pd.DataFrame(set_order_list, columns=col_list)\n\n return RET_OK, set_order_table","def UpdateStatus(self,pid):\n\t\tb1=Rents.objects.filter(paymentid_id=pid).first()\n\t\tamount=Payment.objects.filter(paymentid=pid).values('amount')\n\t\tb=b1.__dict__\n\t\tquant=b['quantity']\n\t\tbookid=b['bookid_id']\n\t\tprice=amount[0]['amount']/quant\n\t\t#price=float(\"{.2f}\".format(amount[0]['amount']))/float(\"{0:.2f}\".format(quant))\n\t\tRents.objects.filter(paymentid_id=pid).update(status='r')\n\t\tBook.objects.filter(bookid=bookid).update(quantity=F('quantity')+quant)\n\t\tStatus.objects.filter(ISBN=b['ISBN'],rentprice=price).update(quantity=F('quantity')+quant)\n\t\tUpload.objects.filter(owner_id_id=b['owner_id_id'],sellprice=price).update(qtyavailable=F('qtyavailable')+quant)\n\t\tself.notifyBuyer(b['ISBN'])","def change_status(self, status, application_id):","def change_status(self):\n if self.status == 'in progress':\n self.status = 'done'\n return self.status\n elif self.status == 'done':\n self.status = 'in progress'\n self.eisenhower_priority()\n return self.status","def update_order():","def update_order():","def api_mark_order_served(request, id):\n\n close_old_connections()\n \n # Not allow unauthenticated users.\n if not request.user.is_authenticated:\n return HttpResponseForbidden(\"You're not authenticated.\")\n \n # Get the order.\n order = Order.objects.get(id=id)\n \n # Not marking it as served if it isn't even ready yet.\n if not order.ready:\n return HttpResponseForbidden(\"This order is not yet ready!\")\n \n # Mark it as served and save it.\n order.served = not order.served\n order.save()\n\n close_old_connections()\n\n return HttpResponse('Marked as served')","def test_change_order_status_when_order_does_not_exist(self):\n response = self.api_test_client.put('{}/orders/1000'.format(\n self.BASE_URL), json={'order_status': 'accepted'})\n\n self.assertEqual(response.status_code, 404)\n self.assertEqual(response_as_json(\n response)['message'],\n 'Order with id 1000 not found')","def _update_status(self):\n self._db_update({'status': self.status})","def set_order_done():\n data = select_data_source()\n user = data['user']\n order_id = data['id']\n \n if check_user_permission(user) : return permission_denied_return\n \n db = database.getdb()\n \n ### Check if is valid.\n \n cmd = 'select passed from orders where id==\"{0}\"'.format(order_id)\n order_valid = db.execute(cmd).fetchall()[0][0]\n if order_valid == 0 :\n return finish_invalid_return\n \n ### Check if is done.\n cmd = 'select done from orders where id==\"{0}\"'.format(order_id)\n order_done = db.execute(cmd).fetchall()[0][0]\n if order_done != 0 :\n return finish_done_return\n \n ### All check done.\n ### Set it to done.\n cmd = 'update orders set done=1 where id==\"{0}\"'.format(order_id)\n db.execute(cmd)\n db.commit()\n print('user sets order {0} to be done.'.format(user))\n \n return finish_complete_return","def test_order_update_status_function(self):\n order = OrderInfo.objects.create(user=self.create_test_user())\n self.assertIsInstance(order.ordered, datetime)\n self.assertIsNone(order.cooked)\n self.assertIsNone(order.delivered)\n\n order.update_current_state()\n self.assertIsInstance(order.cooked, datetime)\n self.assertIsNone(order.delivered)\n\n order.update_current_state()\n self.assertIsInstance(order.cooked, datetime)\n self.assertIsInstance(order.delivered, datetime)","def mark_ready_for_review(self, user: User) -> None:\n from .exceptions import OperationForbiddenError, OrderEmptyError\n\n # If order is not in the \"CREATED\" state, raise an\n # OperationForbiddenError\n if not self.is_created:\n raise OperationForbiddenError(\n self.STATE_CHANGE_FORBIDDEN_ERROR_MSG % {\n 'current_state': Order.OrderState.get_choice_display(\n self.state\n ),\n 'new_state': Order.OrderState.PENDING.choice_display\n }\n )\n\n # If the order's item list is empty, raise an OrderEmptyError\n if not self.orderitem_set.exists():\n raise OrderEmptyError(\n self,\n 'An order should contain at least one Order item before it '\n 'can be marked as \"PENDING\".'\n )\n\n # Update the order to \"PENDING\" state\n self.update(user, state=Order.OrderState.PENDING.choice_value)","def request_order_status_request(self, req):\n assert req.MsgType == Fix.Tags.MsgType.Values.ORDERSTATUSREQUEST, \\\n \"Order request is not ORDERSTATUSREQUEST\"\n\n params = { \"filter\": \"{\\\"orderID\\\": \\\"%s\\\"}\" % req.OrderID.value }\n return self.api_connector.send_request(\"Order\", RestApiConnector.HTTPMethod.GET, params)","def finish_order(self, order_id):\n request_name = \"get_order_info\"\n\n orders = self.make_request(request_name, url_id=order_id)\n if orders is None:\n print(\"Unsuccessful updating order\")\n return\n order = orders[0]\n update_dict = dict()\n for key in order:\n if str(key)[0] == \"_\":\n continue\n try:\n update_dict[key.encode('utf-8')] = order[key].encode('utf-8')\n except AttributeError:\n update_dict[key.encode('utf-8')] = order[key]\n\n update_dict['status'] = 'Complete'\n resp = self.make_request('set_inventory_order', url_id=order_id, arguments=update_dict)","def fill_order(self, order: Order) -> None:\n order = self.get_order_by_id(order.id)\n order.status = OrderStatus.FILL","async def on_order_completed(self, order_id: str):\n self._orders = list(filter(lambda order: order['id'] != order_id, self._orders))","def updateStatus(self, status):\n pass","async def on_order_updated(self, order: MetatraderOrder):\n for i in range(len(self._orders)):\n if self._orders[i]['id'] == order['id']:\n self._orders[i] = order\n break\n else:\n self._orders.append(order)","def cook_order(request):\n\torder_id = request.GET.get('order_id', 0)\n\tcs , status = CookStatus.objects.get_or_create(cook_name=request.user)\n\n\tif cs.current_order is None:\n\t\tcs.current_order = Order.objects.get(id=order_id)\n\t\tcs.current_order.status = 'cooking'\n\t\tcs.current_order.tikchen = request.user.username\n\t\tcs.current_order.save()\n\t\tcs.save()\n\n\treturn HttpResponseRedirect(\"/staff/cook_order_list/\")","def __order_status(self):\n log.debug(\"Displaying __order_status\")\n # Find the latest orders\n orders = self.session.query(db.Order) \\\n .filter(db.Order.user == self.user) \\\n .order_by(db.Order.creation_date.desc()) \\\n .limit(20) \\\n .all()\n # Ensure there is at least one order to display\n if len(orders) == 0:\n self.bot.send_message(self.chat.id, self.loc.get(\"error_no_orders\"))\n # Display the order status to the user\n for order in orders:\n self.bot.send_message(self.chat.id, order.text(w=self, session=self.session, user=True))\n # TODO: maybe add a page displayer instead of showing the latest 5 orders","def prepare_order(self, index, order_status):\n if(self.running_qty > 0 and index > 0):\n quantity = self.running_qty\n price = self.get_price_offset3(index)\n elif(self.running_qty < 0 and index < 0):\n quantity = abs(self.running_qty)\n price = self.get_price_offset3(index)\n else:\n quantity = self.ORDER_START_SIZE // 4\n price = self.get_price_offset2(index)\n if (price == None):\n return None\n else:\n return {'price': price, 'orderQty': quantity, 'side': \"Buy\" if index < 0 else \"Sell\"}","def set_status(self, scenario_id, status):\n self.cur.execute(\n \"UPDATE execute_list SET status = %s WHERE id = %s\",\n (status, scenario_id),\n )","def _order_cannot_be_updated_if_not_pending(order_status):\n pecan.abort(400, u._(\"Only PENDING orders can be updated. Order is in the\"\n \"{0} state.\").format(order_status))","def UpdateStatus(self, status):\r\n self.status.update(status)","def update_status(request_id, status):\n pass","def _set_status(self, status):\n with self.status_lock:\n if (status in _ENDING_STATUSES) or (not self.status in _ENDING_STATUSES):\n self.status = status","def set_status(self, status):\n # TODO log to db\n self.status = status","def reject_order(self, order: Order) -> None:\n order = self.get_order_by_id(order.id)\n order.status = OrderStatus.REJECT","def update_status(self, id, status):\n sql = f\"UPDATE incidences SET status = \\'{status}\\'\\\n WHERE incidences.id = {id}\"\n conn = Db().con\n curr = conn.cursor()\n curr.execute(sql)\n conn.commit()","def _status_btn_clicked(root, item):\n sql_status_update = 'UPDATE job SET Job_Status = \"Complete\" WHERE Job_ID = '+str(item[0])+';'\n print (sql_status_update)\n conn = pymysql.connect(host='localhost', user='root', password='#######', db='######')\n a = conn.cursor()\n a.execute(sql_status_update)\n conn.commit()\n a.close()\n conn.close()","def item_status(item_id):\n\n item_completed = request.form.get(\"item_completed\", \"off\")\n list_id = request.form[\"list_id\"]\n\n item_completed = item_completed == \"on\"\n\n to_do_item = ToDoItem.query.get(item_id)\n to_do_item.completed = item_completed\n db.session.commit()\n\n return redirect(f\"/lists/{list_id}\")","def set_status(self, status):\n self.status = status","def set_status(self, status):\n self.status = status","def set_status(self, status):\n self.status = status","async def update_trade_status():\n # GET /api/v3/openOrders - get current open orders\n # GET /api/v3/allOrders - get all orders: active, canceled, or filled\n\n symbol = App.config[\"symbol\"]\n\n # -----\n try:\n open_orders = App.client.get_open_orders(symbol=symbol) # By \"open\" orders they probably mean \"NEW\" or \"PARTIALLY_FILLED\"\n # orders = App.client.get_all_orders(symbol=symbol, limit=10)\n except Exception as e:\n log.error(f\"Binance exception in 'get_open_orders' {e}\")\n return\n\n if not open_orders:\n # -----\n await update_account_balance()\n\n last_kline = App.analyzer.get_last_kline(symbol)\n last_close_price = to_decimal(last_kline[4]) # Close price of kline has index 4 in the list\n\n base_quantity = App.base_quantity # BTC\n btc_assets_in_usd = base_quantity * last_close_price # Cost of available BTC in USD\n\n usd_assets = App.quote_quantity # USD\n\n if usd_assets >= btc_assets_in_usd:\n App.status = \"SOLD\"\n else:\n App.status = \"BOUGHT\"\n\n elif len(open_orders) == 1:\n order = open_orders[0]\n if order.get(\"side\") == SIDE_SELL:\n App.status = \"SELLING\"\n elif order.get(\"side\") == SIDE_BUY:\n App.status = \"BUYING\"\n else:\n log.error(f\"Neither SELL nor BUY side of the order {order}.\")\n return None\n\n else: # Many orders\n log.error(f\"Wrong state. More than one open order. Fix manually.\")\n return None","def test_updating_item_status(self):\n #test original quantity\n self.assertEqual(self.supply1.quantity, 10)\n self.assertEqual(self.supply2.quantity, 10)\n \n modified_po = copy.deepcopy(base_purchase_order)\n modified_po['status'] = 'Received'\n modified_po['items'][0]['id'] = 1\n modified_po['items'][0]['status'] = 'Receieved'\n \n resp = self.client.put('/api/v1/purchase-order/1/',\n format='json',\n data=modified_po)\n \n self.assertEqual(resp.status_code, 200, msg=resp)\n \n po = resp.data\n \n self.assertEqual(Supply.objects.get(pk=1).quantity, 20)","def put(self, order_id):\n body = request.get_json()\n order = db.session.query(models.Order).filter_by(id=order_id).first()\n if order is None:\n return 'Order id not found', 400\n borrower = body.get('borrower')\n borrower = query_user_by_name(borrower)\n if borrower is None:\n return 'User does not exit in the system', 404\n # if invalid_user(borrower.username):\n # return 'Unauthorized user, please login as a user/borrower', 401\n copy_id = body.get('copy_id')\n print(body)\n print(copy_id)\n copy = db.session.query(models.Copy).filter_by(id=copy_id).first()\n if copy is None:\n return 'Copy ID {} not found in system'.format(copy_id), 409\n elif copy.id != copy_id and copy.status == BOOK_COPY_STATUS_UNAVAILABLE:\n return 'The copy of the book is not available', 400\n copy_owner = body.get('copy_owner')\n owner = query_user_by_name(copy_owner)\n if owner is None:\n return 'Copy owner not found in the system'.format(copy_owner), 409\n # return_date = body.get('return_date')\n # if datetime.strptime(return_date, \"%y%m%d\") < datetime.strptime(datetime.utcnow().strftime(\"%Y-%m-%d\"), \"%y%m%d\"):\n # return 'Return date should be later than today', 400\n status = body.get('order_status')\n if status is not None and status < 0 or status > 4:\n return 'Status should between 0-4', 400\n order.parse_body_status(body)\n copy = db.session.query(models.Copy).filter_by(id=order.copy).first()\n if order.status == ORDER_STATUS_COMPLETED or order.status == ORDER_STATUS_DECLINED:\n copy.status = BOOK_COPY_STATUS_AVAILABLE\n else:\n copy.status = BOOK_COPY_STATUS_UNAVAILABLE\n db.session.commit()\n return order.serialize(), 200","def id_status(self, id_status):\n self._id_status = id_status","def mark_refunded(self):\n order = self.clone()\n order.status = Order.STATUS_REFUNDED\n order.save()\n return order","def set_vendor_price_list_status(self, status_items):\n self.multiple_items_selection_from_kendo_dropdown(self.vendor_price_list_status_kendo_dropdown_locator, status_items)\n self.wait_for_ajax_spinner_load()","def onOrderSelected(self, item):\n if self.lstOrders.getMultiSelectedItems() == []:\n self.clearBidData()\n else:\n self.btnCancelOrder.enable()","def received_order(self, order):\n\t\tif order.direction == ORDERDIR.IN:\n\t\t\tself.set_button_light(order.floor, OUTPUT.IN_LIGHTS, 1)\n\t\telse:\n\t\t\tself.startedOrderQueue.put(order)\n\t\tself.orderQueue.add_order(order)\n\t\tself.update_and_send_elevator_info()\n\t\tself.should_drive()","def on_trade_order_check(self, orderid, envtype, status):\n if is_cntrade_order_status_finish(status):\n self._obj_order_sub.del_val(orderid=orderid, envtype=envtype)\n elif (not self._obj_order_sub.has_val(orderid, envtype)) and self._obj_order_sub.has_val(u'', envtype):\n self._obj_order_sub.add_val(orderid, envtype) # record info for subscribe order u''","def onSelected(self, item):\n if not item:\n self.clearBidData()\n else:\n self.enableAddOrder()","def change_approval(self, status):\r\n if status == 'approve':\r\n return self.approve()\r\n elif status == 'disapprove':\r\n return self.disapprove()","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def status(self, status):\n self._status = status","def set_OrderStatus(self, value):\n super(ListOrdersInputSet, self)._set_input('OrderStatus', value)","def _set_status(self):\n result = self._get_status()\n if result and result[0]['state'] == 'aborted':\n raise Exception(\"Aborted because the status flag is set to 'aborted' in dynamodb\")\n\n # record the status\n self.status['timestamp'] = time.strftime(\"%Y-%m-%dT%H:%M:%SZ\")\n self.db_handler.update_item({'api_version': TsV2CatalogHandler.api_version}, self.status)","def SetStatus(self, status):\r\n self.status = status","def change_status():\n if self.on:\n connect.SOCKET.sendall(bytes(\"OFF\\n\", \"utf-8\"))\n self.on = False\n else:\n connect.SOCKET.sendall(bytes(\"ON\\n\", \"utf-8\"))\n self.on = True","def slot_user_order(self, dummy_sender, data):\r\n (price, volume, typ, oid, status) = data\r\n found = False\r\n removed = False # was the order removed?\r\n opened = False # did the order change from 'post-pending' to 'open'\"?\r\n voldiff = 0 # did the order volume change (full or partial fill)\r\n if \"executing\" in status:\r\n # don't need this status at all\r\n return\r\n if \"post-pending\" in status:\r\n # don't need this status at all\r\n return\r\n if \"removed\" in status:\r\n for i in range(len(self.owns)):\r\n if self.owns[i].oid == oid:\r\n order = self.owns[i]\r\n\r\n # work around MtGox strangeness:\r\n # for some reason it will send a \"completed_passive\"\r\n # immediately followed by a \"completed_active\" when a\r\n # market order is filled and removed. Since \"completed_passive\"\r\n # is meant for limit orders only we will just completely\r\n # IGNORE all \"completed_passive\" if it affects a market order,\r\n # there WILL follow a \"completed_active\" immediately after.\r\n if order.price == 0:\r\n if \"passive\" in status:\r\n # ignore it, the correct one with\r\n # \"active\" will follow soon\r\n return\r\n\r\n self.debug(\r\n \"### removing order %s \" % oid,\r\n \"price:\", self.gox.quote2str(order.price),\r\n \"type:\", order.typ)\r\n\r\n # remove it from owns...\r\n self.owns.pop(i)\r\n\r\n # ...and update own volume cache in the bids or asks\r\n self._update_level_own_volume(\r\n order.typ,\r\n order.price,\r\n self.get_own_volume_at(order.price, order.typ)\r\n )\r\n removed = True\r\n break\r\n else:\r\n for order in self.owns:\r\n if order.oid == oid:\r\n found = True\r\n self.debug(\r\n \"### updating order %s \" % oid,\r\n \"volume:\", self.gox.base2str(volume),\r\n \"status:\", status)\r\n voldiff = volume - order.volume\r\n opened = (order.status != \"open\" and status == \"open\")\r\n order.volume = volume\r\n order.status = status\r\n break\r\n\r\n if not found:\r\n # This can happen if we added the order with a different\r\n # application or the gox server sent the user_order message\r\n # before the reply to \"order/add\" (this can happen because\r\n # actually there is no guarantee which one arrives first).\r\n # We will treat this like a reply to \"order/add\"\r\n self.add_own(Order(price, volume, typ, oid, status))\r\n\r\n # The add_own() method has handled everything that was needed\r\n # for new orders and also emitted all signals already, we\r\n # can immediately return here because the job is done.\r\n return\r\n\r\n # update level own volume cache\r\n self._update_level_own_volume(\r\n typ, price, self.get_own_volume_at(price, typ))\r\n\r\n # We try to help the strategy with tracking the orders as good\r\n # as we can by sending different signals for different events.\r\n if removed:\r\n reason = self.gox.msg[\"user_order\"][\"reason\"]\r\n self.signal_own_removed(self, (order, reason))\r\n if opened:\r\n self.signal_own_opened(self, (order))\r\n if voldiff:\r\n self.signal_own_volume(self, (order, voldiff))\r\n self.signal_changed(self, None)\r\n self.signal_owns_changed(self, None)","def change_status(self):\n if self.status == \"Still Loaned\":\n self.status = \"Given Back\"\n else:\n self.status = \"Still Loaned\"","def update_status(request):\n tasklist = request.GET.get(\"tasklist\")\n pk = request.GET.get(\"pk\")\n status = request.GET.get(\"status\")\n qs = Todo.objects.get(pk=pk)\n qs.status = status\n if status == \"Done\":\n qs.close()\n elif status == \"Undone\":\n qs.reopen()\n elif status == \"In-Progress\":\n qs.in_progress()\n qs.save()\n return redirect(\"tasks\", tasklist=tasklist)","def change_status(self, status):\n for option in status:\n response = requests.patch(self.base_url + 'settings', headers=self.headers, json={option: status.get(option)})\n print(f'[Mudando {option}] {response.status_code} - {response.ok}')","def status_update(request, id=None):\n #obj = Todo.objects.all()\n user = request.user if request.user.is_authenticated else None\n Todo.objects.filter(id=id).update(mark_done=True, answered_by= user)\n return redirect('lists:alllist')","async def status(self, ctx:utils.Context, status:str):\n\n status_o = getattr(discord.Status, status.lower())\n await self.bot.change_presence(activity=self.bot.guilds[0].me.activity, status=status_o)","def set_status(self, status):\n if not status == self._status:\n self._status = status\n self.winstance.send_event('State changed to ' + self._status)\n\n self.completed = not self.parent_node.is_job or \\\n self._status == 'COMPLETED'\n\n if self.completed:\n self.publish()\n\n if not self.parent_node.is_job:\n self.failed = False\n else:\n self.failed = self.parent_node.is_job and \\\n (self._status == 'BOOT_FAIL' or\n self._status == 'CANCELLED' or\n self._status == 'FAILED' or\n self._status == 'REVOKED' or\n self._status == 'TIMEOUT')","async def change_status(self, status: str) -> int:\n data = {'status': str(status)}\n r = await self.request.request(url='https://www.roblox.com/home/updatestatus', method='POST', data=j.dumps(data))\n return r.status_code","def setComicStatus(self, handles, status):\n db.execute(\"update comics set status=%s where handle in ('\" + \"', '\".join(handles) + \"')\", status)","def update(self, instance, validated_data):\n\n # If an order is cancelled or delivered, it cannot be modified.\n if instance.status == CANCELLED or instance.status == DELIVERED:\n raise exceptions.PermissionDenied('This order cannot be modified.')\n\n # If an order is already confirmed but UI/agent sends another confirmation request by mistake,\n # we deny it as each confirmation is a big operation that includes generating invoices/ledger entries.\n if instance.status == validated_data['status'] == CONFIRMED:\n raise exceptions.PermissionDenied('This order is already confirmed.')\n\n if instance.status == ACCEPTED and validated_data['status'] == CONFIRMED:\n # 1. Transition: accepted -> confirmed\n instance.status = validated_data.get('status')\n elif instance.status == CONFIRMED and validated_data['status'] in [CANCELLED, DELIVERED]:\n # 2. Transition: confirmed -> cancelled/delivered and return\n instance.status = validated_data.get('status')\n instance.save(update_fields=['status'])\n return instance\n else:\n # In case of any invalid transition, reject it.\n raise exceptions.PermissionDenied('There seems to be some discrepancy. Please contact your agent.')\n\n # Get exclusive lock on all relevant data rows\n orderlines = instance.orderlines.select_for_update().select_related('product').all()\n\n # Do order and product update in a single transaction\n with transaction.atomic():\n\n # Validate that order can be approved.\n self._validate_units_and_balance_in_orderlines(orderlines, instance.user)\n\n for orderline in orderlines:\n\n # Decrement product stock count by orderline(buying) requirement\n product = orderline.product\n product.units = F('units') - orderline.units\n product.save(update_fields=['units'])\n\n # Lock current standing price into the orderline, calculate sub total and lock it.\n product_price = product.price\n orderline.confirmed_price = product_price\n orderline.locked = CONFIRMED\n orderline.sub_total = product_price * F('units')\n orderline.save(update_fields=['confirmed_price', 'locked', 'sub_total'])\n\n # Mark order as confirmed.\n instance.save(update_fields=['status'])\n return instance","def set_status(self, new_status):\n if new_status == self.status:\n return\n\n old_status = self.status\n\n if new_status not in self.available_statuses():\n raise exceptions.InvalidOrderStatus(\n _(\n \"'%(new_status)s' is not a valid status for order %(number)s\"\n \" (current status: '%(status)s')\"\n )\n % {\n \"new_status\": new_status,\n \"number\": self.number,\n \"status\": self.status,\n }\n )\n self.status = new_status\n if new_status in self.cascade:\n new_line_status = self.cascade[new_status]\n for line in self.lines.all():\n if new_line_status in line.available_statuses():\n line.status = new_line_status\n line.save()\n self.save()\n\n # Send signal for handling status changed\n order_status_changed.send(\n sender=self,\n order=self,\n old_status=old_status,\n new_status=new_status,\n )\n\n self._create_order_status_change(old_status, new_status)","async def _check_order_update(self, *args, **kwargs):\n order_nos = list(self._orders.keys())\n if not order_nos:\n return\n for order_no in order_nos:\n success, error = await self._rest_api.get_order_status(order_no)\n if error:\n return\n await self._update_order(success[\"data\"][0])","def on_order(self, order: OrderData):\n # print(\"on_order\")\n # print(order)\n pass","async def get_order_status(self, symbol, order_id, client_order_id):\n params = {\n \"symbol\": symbol,\n \"orderId\": str(order_id),\n \"origClientOrderId\": client_order_id,\n \"timestamp\": tools.get_cur_timestamp_ms()\n }\n success, error = await self.request(\"GET\", \"/api/v3/order\", params=params, auth=True)\n return success, error","def _create_order(self, order_status):\n if order_status['is_cancelled']:\n status = ORDER_STATUS.CANCELLED\n elif not order_status['is_live']:\n log.info('found executed order {}'.format(order_status))\n status = ORDER_STATUS.FILLED\n else:\n status = ORDER_STATUS.OPEN\n\n amount = float(order_status['original_amount'])\n filled = float(order_status['executed_amount'])\n\n if order_status['side'] == 'sell':\n amount = -amount\n filled = -filled\n\n price = float(order_status['price'])\n order_type = order_status['type']\n\n stop_price = None\n limit_price = None\n\n # TODO: is this comprehensive enough?\n if order_type.endswith('limit'):\n limit_price = price\n elif order_type.endswith('stop'):\n stop_price = price\n\n executed_price = float(order_status['avg_execution_price'])\n\n # TODO: bitfinex does not specify comission. I could calculate it but not sure if it's worth it.\n commission = None\n\n date = pd.Timestamp.utcfromtimestamp(float(order_status['timestamp']))\n date = pytz.utc.localize(date)\n order = Order(\n dt=date,\n asset=self.assets[order_status['symbol']],\n amount=amount,\n stop=stop_price,\n limit=limit_price,\n filled=filled,\n id=str(order_status['id']),\n commission=commission\n )\n order.status = status\n\n return order, executed_price","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status","def status(self, status):\n\n self._status = status"],"string":"[\n \"async def update_order_status():\\n symbol = App.config[\\\"symbol\\\"]\\n\\n # Get currently active order and id (if any)\\n order = App.order\\n order_id = order.get(\\\"orderId\\\", 0) if order else 0\\n if not order_id:\\n log.error(f\\\"Wrong state or use: check order status cannot find the order id.\\\")\\n return None\\n\\n # -----\\n # Retrieve order from the server\\n try:\\n new_order = App.client.get_order(symbol=symbol, orderId=order_id)\\n except Exception as e:\\n log.error(f\\\"Binance exception in 'get_order' {e}\\\")\\n return\\n\\n # Impose and overwrite the new order information\\n if new_order:\\n order.update(new_order)\\n else:\\n return None\\n\\n # Now order[\\\"status\\\"] contains the latest status of the order\\n return order[\\\"status\\\"]\",\n \"def order_update_status():\\n result = order_obj.order_update_status(request.forms) \\n return result\",\n \"def api_mark_order_ready(request, id):\\n\\n close_old_connections()\\n \\n # Not marking it as served if it isn't even ready yet.\\n if not request.user.is_authenticated:\\n return HttpResponseForbidden(\\\"You're not authenticated.\\\")\\n \\n # Get the order.\\n order = Order.objects.get(id=id)\\n \\n # Mark the order as served and save it.\\n order.ready = not order.ready\\n order.save()\\n\\n close_old_connections()\\n\\n return HttpResponse('Marked as ready')\",\n \"def update_specific_order(self,status,order_id):\\n self.query = \\\"UPDATE orders SET order_status=%s WHERE order_id=%s\\\"\\n self.input = (status,order_id) #tuple to support indexing\\n self.query_1 = \\\"SELECT order_id FROM orders ORDER BY order_id DESC LIMIT 1.\\\"\\n self.query_2 = \\\"SELECT * FROM orders WHERE order_id=%s\\\"\\n self.input_2 = (order_id,) #tuple to support indexing\\n self.event = \\\"admin_update_specific_order\\\"\\n self.error = \\\"Invalid order id\\\"\\n self.message = \\\"Successfully updated the order.\\\"\\n self.order_id = order_id\\n self.db_error = None\",\n \"def mark_completed(self, order_id=None):\\n self.status = \\\"paid\\\"\\n if order_id and not self.order_id:\\n self.order_id = order_id\\n print(\\\"Order completed\\\")\\n self.save()\",\n \"def change_status(id):\\n query = \\\"\\\"\\\"UPDATE parcels SET status = %s WHERE id = %s\\\"\\\"\\\"\\n tuple =('delivered' , id)\\n db.insert(query, tuple)\",\n \"def status(self, id):\",\n \"def test_manager_change_order_status(self):\\n self.client.force_authenticate(self.user)\\n cancel = \\\"CA\\\"\\n url = reverse('order-set_status', args=[self.order.id])\\n resp = self.client.patch(url, data={\\n \\\"status\\\": cancel\\n })\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n new_status = Order.objects.values(\\\"status\\\").get(pk=self.order.id)\\n self.assertEqual(new_status[\\\"status\\\"], cancel)\\n\\n with self.subTest('customer can not change order status'):\\n self.user.role = get_user_model().CUSTOMER\\n self.client.force_authenticate(self.user)\\n resp = self.client.patch(url, data={\\n \\\"status\\\": cancel\\n })\\n self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)\",\n \"def test_update_order(self):\\n response = self.api_test_client.put('{}/orders/1'.format(\\n self.BASE_URL), json={'order_status': 'accepted'})\\n\\n self.assertEqual(response.status_code, 201)\\n self.assertTrue(\\n response_as_json(response)['order']['status_updated_on'])\\n self.assertEqual(\\n response_as_json(response)['order']['order_status'], 'accepted')\",\n \"def update_order(self, order):\\n order.order_id = self.order_id\\n order.average_price = self.avg_execution_price\\n order.symbol = self.symbol\\n order.side = self.side\\n order.type = self.order_type\\n order.amount = self.original_amount\\n order.price = self.price\\n order.filled = self.executed_amount\\n order.remaining = self.remaining_amount\\n if self.is_cancelled:\\n order.status = exchanges.Order.Status.CANCELLED\\n elif self.is_live:\\n order.status = exchanges.Order.Status.OPEN\\n else:\\n order.status = exchanges.Order.Status.CLOSED\\n return order\",\n \"def set_add_dispute_status(self, status):\\n self.single_selection_from_kendo_dropdown(self.add_dispute_status_kendo_dropdown_locator, status)\\n self.wait_for_ajax_spinner_load()\",\n \"def test_admin_change_order_status(self):\\n # Test unregistered id\\n # Correct format but not there\\n response = self.client.put(\\n 'api/v1/parcels/35420', headers=self.admin_token_dict)\\n data = json.loads(response.data)\\n self.assertEqual(response.status_code, 400)\\n self.assertEqual(\\n data, {'message': 'No Parcel delivery order with that id'})\\n # Test invalid format id\\n response = self.client.put(\\n 'api/v1/parcels/35uh420', headers=self.admin_token_dict) # Incorrect id format\\n data = json.loads(response.data)\\n self.assertEqual(response.status_code, 400)\\n self.assertEqual(data, {'message': 'Wrong id format'})\",\n \"def put(self):\\n request_data = json.loads(request.data)\\n print(request_data)\\n order_id = request_data['order_id']\\n status = request_data['status']\\n MM.update_order_status(ObjectId(order_id), status)\\n return {\\\"message\\\": \\\"Order Status Updated\\\"}, 200\",\n \"def set_order_status(self, status, orderid=0, envtype=0):\\n if int(status) not in TRADE_CN.REV_ORDER_STATUS:\\n error_str = ERROR_STR_PREFIX + \\\"the type of status is wrong \\\"\\n return RET_ERROR, error_str\\n\\n if not TRADE_CN.check_envtype_cn(envtype):\\n error_str = ERROR_STR_PREFIX + \\\"the type of environment param is wrong \\\"\\n return RET_ERROR, error_str\\n\\n query_processor = self._get_sync_query_processor(SetOrderStatusCN.cn_pack_req,\\n SetOrderStatusCN.cn_unpack_rsp)\\n\\n # the keys of kargs should be corresponding to the actual function arguments\\n kargs = {'cookie': str(self.cookie), 'envtype': str(envtype), 'localid': str(0),\\n 'orderid': str(orderid), 'status': str(status)}\\n\\n ret_code, msg, set_order_list = query_processor(**kargs)\\n if ret_code != RET_OK:\\n return RET_ERROR, msg\\n\\n col_list = ['envtype', 'orderID']\\n set_order_table = pd.DataFrame(set_order_list, columns=col_list)\\n\\n return RET_OK, set_order_table\",\n \"def UpdateStatus(self,pid):\\n\\t\\tb1=Rents.objects.filter(paymentid_id=pid).first()\\n\\t\\tamount=Payment.objects.filter(paymentid=pid).values('amount')\\n\\t\\tb=b1.__dict__\\n\\t\\tquant=b['quantity']\\n\\t\\tbookid=b['bookid_id']\\n\\t\\tprice=amount[0]['amount']/quant\\n\\t\\t#price=float(\\\"{.2f}\\\".format(amount[0]['amount']))/float(\\\"{0:.2f}\\\".format(quant))\\n\\t\\tRents.objects.filter(paymentid_id=pid).update(status='r')\\n\\t\\tBook.objects.filter(bookid=bookid).update(quantity=F('quantity')+quant)\\n\\t\\tStatus.objects.filter(ISBN=b['ISBN'],rentprice=price).update(quantity=F('quantity')+quant)\\n\\t\\tUpload.objects.filter(owner_id_id=b['owner_id_id'],sellprice=price).update(qtyavailable=F('qtyavailable')+quant)\\n\\t\\tself.notifyBuyer(b['ISBN'])\",\n \"def change_status(self, status, application_id):\",\n \"def change_status(self):\\n if self.status == 'in progress':\\n self.status = 'done'\\n return self.status\\n elif self.status == 'done':\\n self.status = 'in progress'\\n self.eisenhower_priority()\\n return self.status\",\n \"def update_order():\",\n \"def update_order():\",\n \"def api_mark_order_served(request, id):\\n\\n close_old_connections()\\n \\n # Not allow unauthenticated users.\\n if not request.user.is_authenticated:\\n return HttpResponseForbidden(\\\"You're not authenticated.\\\")\\n \\n # Get the order.\\n order = Order.objects.get(id=id)\\n \\n # Not marking it as served if it isn't even ready yet.\\n if not order.ready:\\n return HttpResponseForbidden(\\\"This order is not yet ready!\\\")\\n \\n # Mark it as served and save it.\\n order.served = not order.served\\n order.save()\\n\\n close_old_connections()\\n\\n return HttpResponse('Marked as served')\",\n \"def test_change_order_status_when_order_does_not_exist(self):\\n response = self.api_test_client.put('{}/orders/1000'.format(\\n self.BASE_URL), json={'order_status': 'accepted'})\\n\\n self.assertEqual(response.status_code, 404)\\n self.assertEqual(response_as_json(\\n response)['message'],\\n 'Order with id 1000 not found')\",\n \"def _update_status(self):\\n self._db_update({'status': self.status})\",\n \"def set_order_done():\\n data = select_data_source()\\n user = data['user']\\n order_id = data['id']\\n \\n if check_user_permission(user) : return permission_denied_return\\n \\n db = database.getdb()\\n \\n ### Check if is valid.\\n \\n cmd = 'select passed from orders where id==\\\"{0}\\\"'.format(order_id)\\n order_valid = db.execute(cmd).fetchall()[0][0]\\n if order_valid == 0 :\\n return finish_invalid_return\\n \\n ### Check if is done.\\n cmd = 'select done from orders where id==\\\"{0}\\\"'.format(order_id)\\n order_done = db.execute(cmd).fetchall()[0][0]\\n if order_done != 0 :\\n return finish_done_return\\n \\n ### All check done.\\n ### Set it to done.\\n cmd = 'update orders set done=1 where id==\\\"{0}\\\"'.format(order_id)\\n db.execute(cmd)\\n db.commit()\\n print('user sets order {0} to be done.'.format(user))\\n \\n return finish_complete_return\",\n \"def test_order_update_status_function(self):\\n order = OrderInfo.objects.create(user=self.create_test_user())\\n self.assertIsInstance(order.ordered, datetime)\\n self.assertIsNone(order.cooked)\\n self.assertIsNone(order.delivered)\\n\\n order.update_current_state()\\n self.assertIsInstance(order.cooked, datetime)\\n self.assertIsNone(order.delivered)\\n\\n order.update_current_state()\\n self.assertIsInstance(order.cooked, datetime)\\n self.assertIsInstance(order.delivered, datetime)\",\n \"def mark_ready_for_review(self, user: User) -> None:\\n from .exceptions import OperationForbiddenError, OrderEmptyError\\n\\n # If order is not in the \\\"CREATED\\\" state, raise an\\n # OperationForbiddenError\\n if not self.is_created:\\n raise OperationForbiddenError(\\n self.STATE_CHANGE_FORBIDDEN_ERROR_MSG % {\\n 'current_state': Order.OrderState.get_choice_display(\\n self.state\\n ),\\n 'new_state': Order.OrderState.PENDING.choice_display\\n }\\n )\\n\\n # If the order's item list is empty, raise an OrderEmptyError\\n if not self.orderitem_set.exists():\\n raise OrderEmptyError(\\n self,\\n 'An order should contain at least one Order item before it '\\n 'can be marked as \\\"PENDING\\\".'\\n )\\n\\n # Update the order to \\\"PENDING\\\" state\\n self.update(user, state=Order.OrderState.PENDING.choice_value)\",\n \"def request_order_status_request(self, req):\\n assert req.MsgType == Fix.Tags.MsgType.Values.ORDERSTATUSREQUEST, \\\\\\n \\\"Order request is not ORDERSTATUSREQUEST\\\"\\n\\n params = { \\\"filter\\\": \\\"{\\\\\\\"orderID\\\\\\\": \\\\\\\"%s\\\\\\\"}\\\" % req.OrderID.value }\\n return self.api_connector.send_request(\\\"Order\\\", RestApiConnector.HTTPMethod.GET, params)\",\n \"def finish_order(self, order_id):\\n request_name = \\\"get_order_info\\\"\\n\\n orders = self.make_request(request_name, url_id=order_id)\\n if orders is None:\\n print(\\\"Unsuccessful updating order\\\")\\n return\\n order = orders[0]\\n update_dict = dict()\\n for key in order:\\n if str(key)[0] == \\\"_\\\":\\n continue\\n try:\\n update_dict[key.encode('utf-8')] = order[key].encode('utf-8')\\n except AttributeError:\\n update_dict[key.encode('utf-8')] = order[key]\\n\\n update_dict['status'] = 'Complete'\\n resp = self.make_request('set_inventory_order', url_id=order_id, arguments=update_dict)\",\n \"def fill_order(self, order: Order) -> None:\\n order = self.get_order_by_id(order.id)\\n order.status = OrderStatus.FILL\",\n \"async def on_order_completed(self, order_id: str):\\n self._orders = list(filter(lambda order: order['id'] != order_id, self._orders))\",\n \"def updateStatus(self, status):\\n pass\",\n \"async def on_order_updated(self, order: MetatraderOrder):\\n for i in range(len(self._orders)):\\n if self._orders[i]['id'] == order['id']:\\n self._orders[i] = order\\n break\\n else:\\n self._orders.append(order)\",\n \"def cook_order(request):\\n\\torder_id = request.GET.get('order_id', 0)\\n\\tcs , status = CookStatus.objects.get_or_create(cook_name=request.user)\\n\\n\\tif cs.current_order is None:\\n\\t\\tcs.current_order = Order.objects.get(id=order_id)\\n\\t\\tcs.current_order.status = 'cooking'\\n\\t\\tcs.current_order.tikchen = request.user.username\\n\\t\\tcs.current_order.save()\\n\\t\\tcs.save()\\n\\n\\treturn HttpResponseRedirect(\\\"/staff/cook_order_list/\\\")\",\n \"def __order_status(self):\\n log.debug(\\\"Displaying __order_status\\\")\\n # Find the latest orders\\n orders = self.session.query(db.Order) \\\\\\n .filter(db.Order.user == self.user) \\\\\\n .order_by(db.Order.creation_date.desc()) \\\\\\n .limit(20) \\\\\\n .all()\\n # Ensure there is at least one order to display\\n if len(orders) == 0:\\n self.bot.send_message(self.chat.id, self.loc.get(\\\"error_no_orders\\\"))\\n # Display the order status to the user\\n for order in orders:\\n self.bot.send_message(self.chat.id, order.text(w=self, session=self.session, user=True))\\n # TODO: maybe add a page displayer instead of showing the latest 5 orders\",\n \"def prepare_order(self, index, order_status):\\n if(self.running_qty > 0 and index > 0):\\n quantity = self.running_qty\\n price = self.get_price_offset3(index)\\n elif(self.running_qty < 0 and index < 0):\\n quantity = abs(self.running_qty)\\n price = self.get_price_offset3(index)\\n else:\\n quantity = self.ORDER_START_SIZE // 4\\n price = self.get_price_offset2(index)\\n if (price == None):\\n return None\\n else:\\n return {'price': price, 'orderQty': quantity, 'side': \\\"Buy\\\" if index < 0 else \\\"Sell\\\"}\",\n \"def set_status(self, scenario_id, status):\\n self.cur.execute(\\n \\\"UPDATE execute_list SET status = %s WHERE id = %s\\\",\\n (status, scenario_id),\\n )\",\n \"def _order_cannot_be_updated_if_not_pending(order_status):\\n pecan.abort(400, u._(\\\"Only PENDING orders can be updated. Order is in the\\\"\\n \\\"{0} state.\\\").format(order_status))\",\n \"def UpdateStatus(self, status):\\r\\n self.status.update(status)\",\n \"def update_status(request_id, status):\\n pass\",\n \"def _set_status(self, status):\\n with self.status_lock:\\n if (status in _ENDING_STATUSES) or (not self.status in _ENDING_STATUSES):\\n self.status = status\",\n \"def set_status(self, status):\\n # TODO log to db\\n self.status = status\",\n \"def reject_order(self, order: Order) -> None:\\n order = self.get_order_by_id(order.id)\\n order.status = OrderStatus.REJECT\",\n \"def update_status(self, id, status):\\n sql = f\\\"UPDATE incidences SET status = \\\\'{status}\\\\'\\\\\\n WHERE incidences.id = {id}\\\"\\n conn = Db().con\\n curr = conn.cursor()\\n curr.execute(sql)\\n conn.commit()\",\n \"def _status_btn_clicked(root, item):\\n sql_status_update = 'UPDATE job SET Job_Status = \\\"Complete\\\" WHERE Job_ID = '+str(item[0])+';'\\n print (sql_status_update)\\n conn = pymysql.connect(host='localhost', user='root', password='#######', db='######')\\n a = conn.cursor()\\n a.execute(sql_status_update)\\n conn.commit()\\n a.close()\\n conn.close()\",\n \"def item_status(item_id):\\n\\n item_completed = request.form.get(\\\"item_completed\\\", \\\"off\\\")\\n list_id = request.form[\\\"list_id\\\"]\\n\\n item_completed = item_completed == \\\"on\\\"\\n\\n to_do_item = ToDoItem.query.get(item_id)\\n to_do_item.completed = item_completed\\n db.session.commit()\\n\\n return redirect(f\\\"/lists/{list_id}\\\")\",\n \"def set_status(self, status):\\n self.status = status\",\n \"def set_status(self, status):\\n self.status = status\",\n \"def set_status(self, status):\\n self.status = status\",\n \"async def update_trade_status():\\n # GET /api/v3/openOrders - get current open orders\\n # GET /api/v3/allOrders - get all orders: active, canceled, or filled\\n\\n symbol = App.config[\\\"symbol\\\"]\\n\\n # -----\\n try:\\n open_orders = App.client.get_open_orders(symbol=symbol) # By \\\"open\\\" orders they probably mean \\\"NEW\\\" or \\\"PARTIALLY_FILLED\\\"\\n # orders = App.client.get_all_orders(symbol=symbol, limit=10)\\n except Exception as e:\\n log.error(f\\\"Binance exception in 'get_open_orders' {e}\\\")\\n return\\n\\n if not open_orders:\\n # -----\\n await update_account_balance()\\n\\n last_kline = App.analyzer.get_last_kline(symbol)\\n last_close_price = to_decimal(last_kline[4]) # Close price of kline has index 4 in the list\\n\\n base_quantity = App.base_quantity # BTC\\n btc_assets_in_usd = base_quantity * last_close_price # Cost of available BTC in USD\\n\\n usd_assets = App.quote_quantity # USD\\n\\n if usd_assets >= btc_assets_in_usd:\\n App.status = \\\"SOLD\\\"\\n else:\\n App.status = \\\"BOUGHT\\\"\\n\\n elif len(open_orders) == 1:\\n order = open_orders[0]\\n if order.get(\\\"side\\\") == SIDE_SELL:\\n App.status = \\\"SELLING\\\"\\n elif order.get(\\\"side\\\") == SIDE_BUY:\\n App.status = \\\"BUYING\\\"\\n else:\\n log.error(f\\\"Neither SELL nor BUY side of the order {order}.\\\")\\n return None\\n\\n else: # Many orders\\n log.error(f\\\"Wrong state. More than one open order. Fix manually.\\\")\\n return None\",\n \"def test_updating_item_status(self):\\n #test original quantity\\n self.assertEqual(self.supply1.quantity, 10)\\n self.assertEqual(self.supply2.quantity, 10)\\n \\n modified_po = copy.deepcopy(base_purchase_order)\\n modified_po['status'] = 'Received'\\n modified_po['items'][0]['id'] = 1\\n modified_po['items'][0]['status'] = 'Receieved'\\n \\n resp = self.client.put('/api/v1/purchase-order/1/',\\n format='json',\\n data=modified_po)\\n \\n self.assertEqual(resp.status_code, 200, msg=resp)\\n \\n po = resp.data\\n \\n self.assertEqual(Supply.objects.get(pk=1).quantity, 20)\",\n \"def put(self, order_id):\\n body = request.get_json()\\n order = db.session.query(models.Order).filter_by(id=order_id).first()\\n if order is None:\\n return 'Order id not found', 400\\n borrower = body.get('borrower')\\n borrower = query_user_by_name(borrower)\\n if borrower is None:\\n return 'User does not exit in the system', 404\\n # if invalid_user(borrower.username):\\n # return 'Unauthorized user, please login as a user/borrower', 401\\n copy_id = body.get('copy_id')\\n print(body)\\n print(copy_id)\\n copy = db.session.query(models.Copy).filter_by(id=copy_id).first()\\n if copy is None:\\n return 'Copy ID {} not found in system'.format(copy_id), 409\\n elif copy.id != copy_id and copy.status == BOOK_COPY_STATUS_UNAVAILABLE:\\n return 'The copy of the book is not available', 400\\n copy_owner = body.get('copy_owner')\\n owner = query_user_by_name(copy_owner)\\n if owner is None:\\n return 'Copy owner not found in the system'.format(copy_owner), 409\\n # return_date = body.get('return_date')\\n # if datetime.strptime(return_date, \\\"%y%m%d\\\") < datetime.strptime(datetime.utcnow().strftime(\\\"%Y-%m-%d\\\"), \\\"%y%m%d\\\"):\\n # return 'Return date should be later than today', 400\\n status = body.get('order_status')\\n if status is not None and status < 0 or status > 4:\\n return 'Status should between 0-4', 400\\n order.parse_body_status(body)\\n copy = db.session.query(models.Copy).filter_by(id=order.copy).first()\\n if order.status == ORDER_STATUS_COMPLETED or order.status == ORDER_STATUS_DECLINED:\\n copy.status = BOOK_COPY_STATUS_AVAILABLE\\n else:\\n copy.status = BOOK_COPY_STATUS_UNAVAILABLE\\n db.session.commit()\\n return order.serialize(), 200\",\n \"def id_status(self, id_status):\\n self._id_status = id_status\",\n \"def mark_refunded(self):\\n order = self.clone()\\n order.status = Order.STATUS_REFUNDED\\n order.save()\\n return order\",\n \"def set_vendor_price_list_status(self, status_items):\\n self.multiple_items_selection_from_kendo_dropdown(self.vendor_price_list_status_kendo_dropdown_locator, status_items)\\n self.wait_for_ajax_spinner_load()\",\n \"def onOrderSelected(self, item):\\n if self.lstOrders.getMultiSelectedItems() == []:\\n self.clearBidData()\\n else:\\n self.btnCancelOrder.enable()\",\n \"def received_order(self, order):\\n\\t\\tif order.direction == ORDERDIR.IN:\\n\\t\\t\\tself.set_button_light(order.floor, OUTPUT.IN_LIGHTS, 1)\\n\\t\\telse:\\n\\t\\t\\tself.startedOrderQueue.put(order)\\n\\t\\tself.orderQueue.add_order(order)\\n\\t\\tself.update_and_send_elevator_info()\\n\\t\\tself.should_drive()\",\n \"def on_trade_order_check(self, orderid, envtype, status):\\n if is_cntrade_order_status_finish(status):\\n self._obj_order_sub.del_val(orderid=orderid, envtype=envtype)\\n elif (not self._obj_order_sub.has_val(orderid, envtype)) and self._obj_order_sub.has_val(u'', envtype):\\n self._obj_order_sub.add_val(orderid, envtype) # record info for subscribe order u''\",\n \"def onSelected(self, item):\\n if not item:\\n self.clearBidData()\\n else:\\n self.enableAddOrder()\",\n \"def change_approval(self, status):\\r\\n if status == 'approve':\\r\\n return self.approve()\\r\\n elif status == 'disapprove':\\r\\n return self.disapprove()\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def status(self, status):\\n self._status = status\",\n \"def set_OrderStatus(self, value):\\n super(ListOrdersInputSet, self)._set_input('OrderStatus', value)\",\n \"def _set_status(self):\\n result = self._get_status()\\n if result and result[0]['state'] == 'aborted':\\n raise Exception(\\\"Aborted because the status flag is set to 'aborted' in dynamodb\\\")\\n\\n # record the status\\n self.status['timestamp'] = time.strftime(\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n self.db_handler.update_item({'api_version': TsV2CatalogHandler.api_version}, self.status)\",\n \"def SetStatus(self, status):\\r\\n self.status = status\",\n \"def change_status():\\n if self.on:\\n connect.SOCKET.sendall(bytes(\\\"OFF\\\\n\\\", \\\"utf-8\\\"))\\n self.on = False\\n else:\\n connect.SOCKET.sendall(bytes(\\\"ON\\\\n\\\", \\\"utf-8\\\"))\\n self.on = True\",\n \"def slot_user_order(self, dummy_sender, data):\\r\\n (price, volume, typ, oid, status) = data\\r\\n found = False\\r\\n removed = False # was the order removed?\\r\\n opened = False # did the order change from 'post-pending' to 'open'\\\"?\\r\\n voldiff = 0 # did the order volume change (full or partial fill)\\r\\n if \\\"executing\\\" in status:\\r\\n # don't need this status at all\\r\\n return\\r\\n if \\\"post-pending\\\" in status:\\r\\n # don't need this status at all\\r\\n return\\r\\n if \\\"removed\\\" in status:\\r\\n for i in range(len(self.owns)):\\r\\n if self.owns[i].oid == oid:\\r\\n order = self.owns[i]\\r\\n\\r\\n # work around MtGox strangeness:\\r\\n # for some reason it will send a \\\"completed_passive\\\"\\r\\n # immediately followed by a \\\"completed_active\\\" when a\\r\\n # market order is filled and removed. Since \\\"completed_passive\\\"\\r\\n # is meant for limit orders only we will just completely\\r\\n # IGNORE all \\\"completed_passive\\\" if it affects a market order,\\r\\n # there WILL follow a \\\"completed_active\\\" immediately after.\\r\\n if order.price == 0:\\r\\n if \\\"passive\\\" in status:\\r\\n # ignore it, the correct one with\\r\\n # \\\"active\\\" will follow soon\\r\\n return\\r\\n\\r\\n self.debug(\\r\\n \\\"### removing order %s \\\" % oid,\\r\\n \\\"price:\\\", self.gox.quote2str(order.price),\\r\\n \\\"type:\\\", order.typ)\\r\\n\\r\\n # remove it from owns...\\r\\n self.owns.pop(i)\\r\\n\\r\\n # ...and update own volume cache in the bids or asks\\r\\n self._update_level_own_volume(\\r\\n order.typ,\\r\\n order.price,\\r\\n self.get_own_volume_at(order.price, order.typ)\\r\\n )\\r\\n removed = True\\r\\n break\\r\\n else:\\r\\n for order in self.owns:\\r\\n if order.oid == oid:\\r\\n found = True\\r\\n self.debug(\\r\\n \\\"### updating order %s \\\" % oid,\\r\\n \\\"volume:\\\", self.gox.base2str(volume),\\r\\n \\\"status:\\\", status)\\r\\n voldiff = volume - order.volume\\r\\n opened = (order.status != \\\"open\\\" and status == \\\"open\\\")\\r\\n order.volume = volume\\r\\n order.status = status\\r\\n break\\r\\n\\r\\n if not found:\\r\\n # This can happen if we added the order with a different\\r\\n # application or the gox server sent the user_order message\\r\\n # before the reply to \\\"order/add\\\" (this can happen because\\r\\n # actually there is no guarantee which one arrives first).\\r\\n # We will treat this like a reply to \\\"order/add\\\"\\r\\n self.add_own(Order(price, volume, typ, oid, status))\\r\\n\\r\\n # The add_own() method has handled everything that was needed\\r\\n # for new orders and also emitted all signals already, we\\r\\n # can immediately return here because the job is done.\\r\\n return\\r\\n\\r\\n # update level own volume cache\\r\\n self._update_level_own_volume(\\r\\n typ, price, self.get_own_volume_at(price, typ))\\r\\n\\r\\n # We try to help the strategy with tracking the orders as good\\r\\n # as we can by sending different signals for different events.\\r\\n if removed:\\r\\n reason = self.gox.msg[\\\"user_order\\\"][\\\"reason\\\"]\\r\\n self.signal_own_removed(self, (order, reason))\\r\\n if opened:\\r\\n self.signal_own_opened(self, (order))\\r\\n if voldiff:\\r\\n self.signal_own_volume(self, (order, voldiff))\\r\\n self.signal_changed(self, None)\\r\\n self.signal_owns_changed(self, None)\",\n \"def change_status(self):\\n if self.status == \\\"Still Loaned\\\":\\n self.status = \\\"Given Back\\\"\\n else:\\n self.status = \\\"Still Loaned\\\"\",\n \"def update_status(request):\\n tasklist = request.GET.get(\\\"tasklist\\\")\\n pk = request.GET.get(\\\"pk\\\")\\n status = request.GET.get(\\\"status\\\")\\n qs = Todo.objects.get(pk=pk)\\n qs.status = status\\n if status == \\\"Done\\\":\\n qs.close()\\n elif status == \\\"Undone\\\":\\n qs.reopen()\\n elif status == \\\"In-Progress\\\":\\n qs.in_progress()\\n qs.save()\\n return redirect(\\\"tasks\\\", tasklist=tasklist)\",\n \"def change_status(self, status):\\n for option in status:\\n response = requests.patch(self.base_url + 'settings', headers=self.headers, json={option: status.get(option)})\\n print(f'[Mudando {option}] {response.status_code} - {response.ok}')\",\n \"def status_update(request, id=None):\\n #obj = Todo.objects.all()\\n user = request.user if request.user.is_authenticated else None\\n Todo.objects.filter(id=id).update(mark_done=True, answered_by= user)\\n return redirect('lists:alllist')\",\n \"async def status(self, ctx:utils.Context, status:str):\\n\\n status_o = getattr(discord.Status, status.lower())\\n await self.bot.change_presence(activity=self.bot.guilds[0].me.activity, status=status_o)\",\n \"def set_status(self, status):\\n if not status == self._status:\\n self._status = status\\n self.winstance.send_event('State changed to ' + self._status)\\n\\n self.completed = not self.parent_node.is_job or \\\\\\n self._status == 'COMPLETED'\\n\\n if self.completed:\\n self.publish()\\n\\n if not self.parent_node.is_job:\\n self.failed = False\\n else:\\n self.failed = self.parent_node.is_job and \\\\\\n (self._status == 'BOOT_FAIL' or\\n self._status == 'CANCELLED' or\\n self._status == 'FAILED' or\\n self._status == 'REVOKED' or\\n self._status == 'TIMEOUT')\",\n \"async def change_status(self, status: str) -> int:\\n data = {'status': str(status)}\\n r = await self.request.request(url='https://www.roblox.com/home/updatestatus', method='POST', data=j.dumps(data))\\n return r.status_code\",\n \"def setComicStatus(self, handles, status):\\n db.execute(\\\"update comics set status=%s where handle in ('\\\" + \\\"', '\\\".join(handles) + \\\"')\\\", status)\",\n \"def update(self, instance, validated_data):\\n\\n # If an order is cancelled or delivered, it cannot be modified.\\n if instance.status == CANCELLED or instance.status == DELIVERED:\\n raise exceptions.PermissionDenied('This order cannot be modified.')\\n\\n # If an order is already confirmed but UI/agent sends another confirmation request by mistake,\\n # we deny it as each confirmation is a big operation that includes generating invoices/ledger entries.\\n if instance.status == validated_data['status'] == CONFIRMED:\\n raise exceptions.PermissionDenied('This order is already confirmed.')\\n\\n if instance.status == ACCEPTED and validated_data['status'] == CONFIRMED:\\n # 1. Transition: accepted -> confirmed\\n instance.status = validated_data.get('status')\\n elif instance.status == CONFIRMED and validated_data['status'] in [CANCELLED, DELIVERED]:\\n # 2. Transition: confirmed -> cancelled/delivered and return\\n instance.status = validated_data.get('status')\\n instance.save(update_fields=['status'])\\n return instance\\n else:\\n # In case of any invalid transition, reject it.\\n raise exceptions.PermissionDenied('There seems to be some discrepancy. Please contact your agent.')\\n\\n # Get exclusive lock on all relevant data rows\\n orderlines = instance.orderlines.select_for_update().select_related('product').all()\\n\\n # Do order and product update in a single transaction\\n with transaction.atomic():\\n\\n # Validate that order can be approved.\\n self._validate_units_and_balance_in_orderlines(orderlines, instance.user)\\n\\n for orderline in orderlines:\\n\\n # Decrement product stock count by orderline(buying) requirement\\n product = orderline.product\\n product.units = F('units') - orderline.units\\n product.save(update_fields=['units'])\\n\\n # Lock current standing price into the orderline, calculate sub total and lock it.\\n product_price = product.price\\n orderline.confirmed_price = product_price\\n orderline.locked = CONFIRMED\\n orderline.sub_total = product_price * F('units')\\n orderline.save(update_fields=['confirmed_price', 'locked', 'sub_total'])\\n\\n # Mark order as confirmed.\\n instance.save(update_fields=['status'])\\n return instance\",\n \"def set_status(self, new_status):\\n if new_status == self.status:\\n return\\n\\n old_status = self.status\\n\\n if new_status not in self.available_statuses():\\n raise exceptions.InvalidOrderStatus(\\n _(\\n \\\"'%(new_status)s' is not a valid status for order %(number)s\\\"\\n \\\" (current status: '%(status)s')\\\"\\n )\\n % {\\n \\\"new_status\\\": new_status,\\n \\\"number\\\": self.number,\\n \\\"status\\\": self.status,\\n }\\n )\\n self.status = new_status\\n if new_status in self.cascade:\\n new_line_status = self.cascade[new_status]\\n for line in self.lines.all():\\n if new_line_status in line.available_statuses():\\n line.status = new_line_status\\n line.save()\\n self.save()\\n\\n # Send signal for handling status changed\\n order_status_changed.send(\\n sender=self,\\n order=self,\\n old_status=old_status,\\n new_status=new_status,\\n )\\n\\n self._create_order_status_change(old_status, new_status)\",\n \"async def _check_order_update(self, *args, **kwargs):\\n order_nos = list(self._orders.keys())\\n if not order_nos:\\n return\\n for order_no in order_nos:\\n success, error = await self._rest_api.get_order_status(order_no)\\n if error:\\n return\\n await self._update_order(success[\\\"data\\\"][0])\",\n \"def on_order(self, order: OrderData):\\n # print(\\\"on_order\\\")\\n # print(order)\\n pass\",\n \"async def get_order_status(self, symbol, order_id, client_order_id):\\n params = {\\n \\\"symbol\\\": symbol,\\n \\\"orderId\\\": str(order_id),\\n \\\"origClientOrderId\\\": client_order_id,\\n \\\"timestamp\\\": tools.get_cur_timestamp_ms()\\n }\\n success, error = await self.request(\\\"GET\\\", \\\"/api/v3/order\\\", params=params, auth=True)\\n return success, error\",\n \"def _create_order(self, order_status):\\n if order_status['is_cancelled']:\\n status = ORDER_STATUS.CANCELLED\\n elif not order_status['is_live']:\\n log.info('found executed order {}'.format(order_status))\\n status = ORDER_STATUS.FILLED\\n else:\\n status = ORDER_STATUS.OPEN\\n\\n amount = float(order_status['original_amount'])\\n filled = float(order_status['executed_amount'])\\n\\n if order_status['side'] == 'sell':\\n amount = -amount\\n filled = -filled\\n\\n price = float(order_status['price'])\\n order_type = order_status['type']\\n\\n stop_price = None\\n limit_price = None\\n\\n # TODO: is this comprehensive enough?\\n if order_type.endswith('limit'):\\n limit_price = price\\n elif order_type.endswith('stop'):\\n stop_price = price\\n\\n executed_price = float(order_status['avg_execution_price'])\\n\\n # TODO: bitfinex does not specify comission. I could calculate it but not sure if it's worth it.\\n commission = None\\n\\n date = pd.Timestamp.utcfromtimestamp(float(order_status['timestamp']))\\n date = pytz.utc.localize(date)\\n order = Order(\\n dt=date,\\n asset=self.assets[order_status['symbol']],\\n amount=amount,\\n stop=stop_price,\\n limit=limit_price,\\n filled=filled,\\n id=str(order_status['id']),\\n commission=commission\\n )\\n order.status = status\\n\\n return order, executed_price\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\",\n \"def status(self, status):\\n\\n self._status = status\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67920375","0.670818","0.66758204","0.6641249","0.65196955","0.6437769","0.6087314","0.6031311","0.5999321","0.59882295","0.5978718","0.5966084","0.59375423","0.59296644","0.59227234","0.5900806","0.58614755","0.5841006","0.5841006","0.58058894","0.57958835","0.5776419","0.57573617","0.5730916","0.57189417","0.57016826","0.56785095","0.5673114","0.5636598","0.5635252","0.5634406","0.56208634","0.5580037","0.55799913","0.55757123","0.5568158","0.5561071","0.5548472","0.5542574","0.55308735","0.55049044","0.5498065","0.5491699","0.5483908","0.5475187","0.5475187","0.5475187","0.54624295","0.54574764","0.5454165","0.54515916","0.5447942","0.54468596","0.5443191","0.54423183","0.54316443","0.5424822","0.5418616","0.54159707","0.54159707","0.54159707","0.54159707","0.54159707","0.54159707","0.54159707","0.5405097","0.5397041","0.53817475","0.5344476","0.534347","0.53364384","0.5319629","0.5316878","0.5316218","0.5311027","0.5302227","0.5301443","0.529895","0.52963144","0.52821606","0.5282012","0.5281435","0.5281128","0.52640784","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918","0.5255918"],"string":"[\n \"0.67920375\",\n \"0.670818\",\n \"0.66758204\",\n \"0.6641249\",\n \"0.65196955\",\n \"0.6437769\",\n \"0.6087314\",\n \"0.6031311\",\n \"0.5999321\",\n \"0.59882295\",\n \"0.5978718\",\n \"0.5966084\",\n \"0.59375423\",\n \"0.59296644\",\n \"0.59227234\",\n \"0.5900806\",\n \"0.58614755\",\n \"0.5841006\",\n \"0.5841006\",\n \"0.58058894\",\n \"0.57958835\",\n \"0.5776419\",\n \"0.57573617\",\n \"0.5730916\",\n \"0.57189417\",\n \"0.57016826\",\n \"0.56785095\",\n \"0.5673114\",\n \"0.5636598\",\n \"0.5635252\",\n \"0.5634406\",\n \"0.56208634\",\n \"0.5580037\",\n \"0.55799913\",\n \"0.55757123\",\n \"0.5568158\",\n \"0.5561071\",\n \"0.5548472\",\n \"0.5542574\",\n \"0.55308735\",\n \"0.55049044\",\n \"0.5498065\",\n \"0.5491699\",\n \"0.5483908\",\n \"0.5475187\",\n \"0.5475187\",\n \"0.5475187\",\n \"0.54624295\",\n \"0.54574764\",\n \"0.5454165\",\n \"0.54515916\",\n \"0.5447942\",\n \"0.54468596\",\n \"0.5443191\",\n \"0.54423183\",\n \"0.54316443\",\n \"0.5424822\",\n \"0.5418616\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.54159707\",\n \"0.5405097\",\n \"0.5397041\",\n \"0.53817475\",\n \"0.5344476\",\n \"0.534347\",\n \"0.53364384\",\n \"0.5319629\",\n \"0.5316878\",\n \"0.5316218\",\n \"0.5311027\",\n \"0.5302227\",\n \"0.5301443\",\n \"0.529895\",\n \"0.52963144\",\n \"0.52821606\",\n \"0.5282012\",\n \"0.5281435\",\n \"0.5281128\",\n \"0.52640784\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\",\n \"0.5255918\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68117625"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4194,"cells":{"query":{"kind":"string","value":"Format trajectory into a list of tuples before they are stored in memory. Trajectory is list of (s,a,r,s,d) tuples"},"document":{"kind":"string","value":"def formatTrajectory(self, trajectory):\n return self.RLModel.formatTrajectory(trajectory)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_trajectory(path: str) -> Optional[List[Dict[str, tuple]]]:\n lines = _get_lines_from_file(path)\n\n ess_file = False\n if path.split('.')[-1] != 'xyz':\n try:\n log = ess_factory(fullpath=path, check_for_errors=False)\n ess_file = True\n except (InputError, RMGInputError):\n ess_file = False\n\n if ess_file:\n if not isinstance(log, GaussianLog):\n raise NotImplementedError(f'Currently parse_trajectory only supports Gaussian files, got {type(log)}')\n traj = list()\n done = False\n i = 0\n while not done:\n if i >= len(lines) or 'Normal termination of Gaussian' in lines[i] or 'Error termination via' in lines[i]:\n done = True\n elif 'Input orientation:' in lines[i]:\n i += 5\n xyz_str = ''\n while len(lines) and '--------------------------------------------' not in lines[i]:\n splits = lines[i].split()\n xyz_str += f'{qcel.periodictable.to_E(int(splits[1]))} {splits[3]} {splits[4]} {splits[5]}\\n'\n i += 1\n traj.append(str_to_xyz(xyz_str))\n i += 1\n\n else:\n # this is not an ESS output file, probably an XYZ format file with several Cartesian coordinates\n skip_line = False\n num_of_atoms = 0\n traj, xyz_lines = list(), list()\n for line in lines:\n splits = line.strip().split()\n if len(splits) == 1 and all([c.isdigit() for c in splits[0]]):\n if len(xyz_lines):\n if len(xyz_lines) != num_of_atoms:\n raise ParserError(f'Could not parse trajectory, expected {num_of_atoms} atoms, '\n f'but got {len(xyz_lines)} for point {len(traj) + 1} in the trajectory.')\n traj.append(str_to_xyz(''.join([xyz_line for xyz_line in xyz_lines])))\n num_of_atoms = int(splits[0])\n skip_line = True\n xyz_lines = list()\n elif skip_line:\n # skip the comment line\n skip_line = False\n continue\n else:\n xyz_lines.append(line)\n\n if len(xyz_lines):\n # add the last point in the trajectory\n if len(xyz_lines) != num_of_atoms:\n raise ParserError(f'Could not parse trajectory, expected {num_of_atoms} atoms, '\n f'but got {len(xyz_lines)} for point {len(traj) + 1} in the trajectory.')\n traj.append(str_to_xyz(''.join([xyz_line for xyz_line in xyz_lines])))\n\n if not len(traj):\n logger.error(f'Could not parse trajectory from {path}')\n return None\n return traj","def simulation_to_lines(data: List(Float))->List(Tuple(Int, Float)):\n result = []\n counter = 0\n for payoff in data:\n result = result + [(counter, payoff)]\n counter+=1\n return result\n\n #print(str(result))","def trajectory(self):\n return Trajectory.createFromTuples(self.points)","def _print_tisserand_lists(self, Trajectory=[]):\n\t\n\timport numpy as np\n\t\n\tn = len(Trajectory);\n\trpl = [];\n\tral = [];\n\tpl = [];\n\tvinfl = [];\n\tfor i in range(n):\n\t\tral.append(Trajectory[i][6]);\n\t\trpl.append(Trajectory[i][5]);\n\t\tpl.append(Trajectory[i][7]);\n\t\tvinfl.append(Trajectory[i][8]);\n\t\n\tprint 'list_ra_python = [',\n\tn = len(ral);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % ral[i],\n\tprint '%f];' % ral[n-1];\n\t\n\tprint 'list_rp_python = [',\n\tn = len(rpl);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % rpl[i],\n\tprint '%f];' % rpl[n-1];\n\t\n\tprint 'list_period_python = [',\n\tn = len(pl);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % pl[i],\n\tprint '%f];' % pl[n-1];\n\t\n\tprint 'list_vinf_python = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % np.linalg.norm(vinfl[i]),\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % np.linalg.norm(vinfl[n-1]);\n\t\n\tprint 'list_vinf_python_x = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][0],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][0];\n\t\n\tprint 'list_vinf_python_y = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][1],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][1];\n\t\n\tprint 'list_vinf_python_z = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][2],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][2];","def format_coords(self, coordinates):\n\n coords = []\n for i in range(0, len(coordinates), 3):\n coords.append(tuple(coordinates[i:i+3]))\n\n return coords","def convert_shapely_points_to_tuples(list_of_points) -> list:\n return [(p.x, p.y) for p in list_of_points]","def get_trajectory(self) -> Tuple:\n # Ensure index is in an allowable range\n assert self.step <= self.num_steps\n # TODO NOTE consider edge case: what happens if this is called right\n # after self.cycle() has been called? does it still work?\n\n # ==\n # Get the trajectory up to current timestep\n o_traj = (self.obs_buffer[:self.step]\n .view(-1, *self.observation_shape)) # (T, *obs_shape)\n h_init = (self.hid_buffer[0]\n .view(-1, self.hidden_state_dim)) # (1, hidden_dim)\n d_traj = (self.don_buffer[:self.step]\n .view(-1, 1)) # (T, 1)\n a_traj = (self.act_buffer[:self.step]\n .view(-1, self.action_dim)) # (T, action_dim)\n\n # Return\n return o_traj, h_init, d_traj, a_traj","def build(self, trajectory):\n buf = StringIO()\n\n print >>buf, str(datetime.datetime.now())\n print >>buf, '%5d' % trajectory.n_atoms\n\n linecount = 0\n for atom in range(trajectory.n_atoms):\n for dim in range(3):\n # need to convert from nm to angstroms by multiplying by ten\n fmt = '%12.7f' % (10 * trajectory.xyz[0, atom, dim])\n assert len(fmt) == 12, 'fmt overflowed writing inpcrd. blowup?'\n buf.write(fmt)\n linecount += 1\n if linecount >= 6:\n buf.write(os.linesep)\n linecount = 0\n\n if trajectory.unitcell_lengths != None:\n if linecount != 0:\n buf.write(os.linesep)\n box = (trajectory.unitcell_lengths[0]*10).tolist()\n box.extend(trajectory.unitcell_angles[0].tolist())\n buf.write(('%12.7f' * 6) % tuple(box))\n \n return buf.getvalue()","def process_coordinates(void: 'ChargeSystem', steps: int) -> list:\n result = [[] for _ in void]\n\n for _ in range(steps):\n for ind, charge in enumerate(void):\n result[ind].append(list(charge.position))\n void.update()\n\n return result","def to_numpy_trajectory(trajectory):\n tx = []\n ty = []\n tyaw = []\n for pose in trajectory:\n tx.append(pose.x)\n ty.append(pose.y)\n tyaw.append(pose.yaw)\n return numpy.asarray([tx, ty, tyaw])","def read_frame_trajectory_file( filename ):\n file = open(filename, \"r\")\n\n timestamps = list()\n path = list()\n\n for line in file:\n # eliminate leading spaces\n line = line.strip()\n\n # ignore comments and empty lines\n if len(line) == 0 or line[0] == '#':\n continue\n\n # divide on whitespace and convert to numbers\n nums = [float(x) for x in line.split()]\n \n # separate out components and build lists\n\n timestamps.append( nums[0] )\n\n origin = list( nums[1:4] )\n unitx = list( nums[4:7] )\n unity = list( nums[7:10] )\n unitz = list( nums[10:13] )\n\n path.append( list( (origin, unitx, unity, unitz ) ) )\n\n return path, timestamps","def get_trajectory(self, sort_by: str = \"trials\") -> tuple[list[float], list[float]]:\n raise NotImplementedError","def dump_ue4_trajectory(name: str, trajectory: typing.Mapping[float, tf.Transform]) -> None:\n with open('unreal_trajectory_{0}.csv'.format(name), 'w') as output_file:\n output_file.write('Name,X,Y,Z,Roll,Pitch,Yaw\\n')\n for idx, timestamp in enumerate(sorted(trajectory.keys())):\n ue_pose = uetf.transform_to_unreal(trajectory[timestamp])\n output_file.write('{name},{x},{y},{z},{roll},{pitch},{yaw}\\n'.format(\n name=idx,\n x=ue_pose.location[0],\n y=ue_pose.location[1],\n z=ue_pose.location[2],\n roll=ue_pose.euler[0],\n pitch=ue_pose.euler[1],\n yaw=ue_pose.euler[2]))","def ex_list(data):\n return tuple(data)","def toListOfTuple(self, df:pd.core.frame.DataFrame) -> List[Tuple]: \n df['TIME_STAMP'] = df['TIME_STAMP'].astype('str')\n records = df.to_records(index=False)\n listOfTuple = list(records)\n return listOfTuple","def get_list(self):\n if self.key == 'L':\n return array_to_list([self.key, self.timing, self.data])\n if self.key == 'T':\n return array_to_list([self.key, self.data, self.timing])\n tmp_data = copy.deepcopy(self.data)\n for i in range(len(self.data)):\n if isinstance(self.data[i], float):\n tmp_data[i] = str('%.3f' % tmp_data[i])\n if tmp_data[i].split('.')[1] == '000':\n tmp_data[i] = tmp_data[i].split('.')[0]\n return array_to_list([self.key, self.easing, self.timing, tmp_data])","def trajectory_to_json(trajectory: Trajectory) -> str:\n # numpy arrays need to be converted to normal tuples\n return json.dumps(trajectory, cls=NumpyEncoder)","def parseTupleList(self,string):\r\n string = string.replace(\"[\",\"\")\r\n string = string.replace(\"),\",\"*\")\r\n string = string.replace(\"(\", \"\")\r\n string = string.replace(\")\", \"\")\r\n string = string.replace(\"]\", \"\")\r\n string = string.split(\"*\")\r\n for i in xrange(len(string)):\r\n string[i] = string[i].split(\",\")\r\n for i in xrange(len(string)):\r\n for j in xrange(len(string[i])):\r\n string[i][j] = int(string[i][j])\r\n string[i] = tuple(string[i])\r\n return string","def compute_trajectory():\n pass","def __str__(self):\n out_str = \"\\n\".join(`\"%.5f, %.5f, %.1f, %s, %s\" % (point[0], point[1], point[2], point[3], point[4])` for point in self.__traectory_list)\n return \"\\'x, y, altitude, capture time, capture date'\\n\"+out_str","def parse_1d_scan_coords(path: str) -> List[Dict[str, tuple]]:\n if not os.path.isfile(path):\n raise InputError(f'Could not find file {path}')\n software = identify_ess(path)\n traj = list()\n\n if software == 'xtb':\n scan_path = os.path.join(os.path.dirname(path), 'xtbscan.log')\n if os.path.isfile(scan_path):\n lines = _get_lines_from_file(scan_path)\n xyz_str = ''\n for line in lines:\n splits = line.split()\n if len(splits) == 1:\n if xyz_str:\n traj.append(str_to_xyz(xyz_str))\n xyz_str = ''\n continue\n if 'energy:' in line:\n continue\n xyz_str += f'{qcel.periodictable.to_E(splits[0])} {splits[1]} {splits[2]} {splits[3]}\\n'\n traj.append(str_to_xyz(xyz_str))\n return traj\n\n lines = _get_lines_from_file(path)\n log = ess_factory(fullpath=path, check_for_errors=False)\n if not isinstance(log, GaussianLog):\n raise NotImplementedError(f'Currently parse_1d_scan_coords only supports Gaussian files, got {type(log)}')\n done = False\n i = 0\n while not done:\n if i >= len(lines) or 'Normal termination of Gaussian' in lines[i] or 'Error termination via' in lines[i]:\n done = True\n elif 'Optimization completed' in lines[i]:\n while i < len(lines) + 10 and 'Input orientation:' not in lines[i] or 'Forces (Hartrees/Bohr)' in lines [i + 7]:\n i += 1\n if 'Error termination via' in lines[i]:\n return traj\n i += 5\n xyz_str, skip_traj = '', False\n while len(lines) and '--------------------------------------------' not in lines[i]:\n if 'DIIS: error' in lines[i]:\n skip_traj = True\n break\n splits = lines[i].split()\n xyz_str += f'{qcel.periodictable.to_E(int(splits[1]))} {splits[3]} {splits[4]} {splits[5]}\\n'\n i += 1\n if not skip_traj:\n traj.append(str_to_xyz(xyz_str))\n i += 1\n return traj","def plot_trajectory(axis, trajectory: typing.Mapping[float, tf.Transform], label: str, style: str = '-') \\\n -> typing.Tuple[float, float]:\n x = []\n y = []\n z = []\n max_point = 0\n min_point = 0\n times = sorted(trajectory.keys())\n first_pose = None\n for timestamp in times:\n pose = trajectory[timestamp]\n if first_pose is None:\n first_pose = pose\n x.append(0)\n y.append(0)\n z.append(0)\n else:\n pose = first_pose.find_relative(pose)\n max_point = max(max_point, pose.location[0], pose.location[1], pose.location[2])\n min_point = min(min_point, pose.location[0], pose.location[1], pose.location[2])\n x.append(pose.location[0])\n y.append(pose.location[1])\n z.append(pose.location[2])\n axis.plot(x, y, z, style, label=label, alpha=0.7)\n return min_point, max_point","def tup_list_maker(tup_list):\n final_list = []\n for item in tup_list:\n index = item[0]\n sentences = item[1]\n for sentence in sentences:\n pair = (index, sentence)\n final_list.append(pair)\n return final_list","def get_tuples(self):\n pattern = list()\n for gi in self.gradual_items:\n temp = tuple([gi.attribute_col, gi.symbol])\n pattern.append(temp)\n return pattern","def coords_to_structure(self) -> None:\n ...","def convert_listofrollouts(paths):\n #print([p[\"observation\"] for p in paths[:2]])\n observations = np.concatenate([path[\"observation\"] for path in paths])\n actions = np.concatenate([path[\"action\"] for path in paths])\n next_observations = np.concatenate([path[\"next_observation\"] for path in paths])\n terminals = np.concatenate([path[\"terminal\"] for path in paths])\n concatenated_rewards = np.concatenate([path[\"reward\"] for path in paths])\n unconcatenated_rewards = [path[\"reward\"] for path in paths]\n #print(\"DONE\")\n return observations, actions, next_observations, terminals, concatenated_rewards, unconcatenated_rewards","def toArray(parsedList):\n interpretCommand = {\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\n 'L' : lambda x, prevL : x[0:2],\n 'M' : lambda x, prevL : x[0:2],\n 'Z' : lambda x, prevL : prevL[0],\n }\n\n points =[]\n for i,(c, arg) in enumerate(parsedList):\n #debug('toArray ', i, c , arg)\n newp = interpretCommand[c](arg, points)\n points.append( newp)\n a=numpy.array( points )\n\n # Some times we have points *very* close to each other\n # these do not bring any meaning full info, so we remove them\n #\n x,y, w,h = computeBox(a)\n sizeC = 0.5*(w+h)\n #deltas = numpy.zeros((len(a),2) )\n deltas = a[1:] - a[:-1] \n #deltas[-1] = a[0] - a[-1]\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\n sortedDind = numpy.argsort(deltaD)\n # expand longuest segments\n nexp = int(len(deltaD)*0.9)\n newpoints=[ None ]*len(a)\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\n for i,ind in enumerate(sortedDind):\n if deltaD[ind]/sizeC<0.005: continue\n if i>nexp:\n np = int(deltaD[ind]/medDelta)\n pL = [a[ind]]\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\n for j in range(np-1):\n f = float(j+1)/np\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\n newpoints[ind] = pL\n else:\n newpoints[ind]=[a[ind]]\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\n newpoints[-1]=[a[-1]]\n\n points = numpy.concatenate([p for p in newpoints if p!=None] )\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\n ## print len(a) ,' ------> ', len(points)\n\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\n\n #return a[keep] , [ parsedList[i] for i in keep]\n #print len(a),' ',len(points)\n return points , []","def build(self, trajectory):\n #TODO Implement?","def transform_trajectory(self, trajectory, theta):\n origin = np.array([trajectory.s_coordinates[0],\n trajectory.d_coordinates[0]])\n\n for step in range(self.t_steps):\n point = np.array([trajectory.s_coordinates[step],\n trajectory.d_coordinates[step]])\n point = self._rotate_vector(point - origin, theta) + origin\n trajectory.s_coordinates[step] = point[0]\n trajectory.d_coordinates[step] = point[1]\n\n return trajectory","def split(self, time: float) -> Tuple['Trajectory','Trajectory']:\n if time <= self.times[0]:\n #split before start of trajectory\n return self.constructor()([time],[self.milestones[0]]),self.constructor()([time]+self.times,[self.milestones[0]]+self.milestones)\n elif time >= self.times[-1]:\n #split after end of trajectory\n return self.constructor()(self.times+[time],self.milestones+[self.milestones[-1]]),self.constructor()([time],[self.milestones[-1]])\n i,u = self.getSegment(time)\n assert i >= 0,\"getSegment returned -1? something must be wrong with the times\"\n #split in middle of trajectory\n splitpt = self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\n front = self.constructor()(self.times[:i+1],self.milestones[:i+1])\n back = self.constructor()(self.times[i+1:],self.milestones[i+1:])\n if u > 0:\n front.times.append(time)\n front.milestones.append(splitpt)\n if u < 1:\n back.times = [time] + back.times\n back.milestones = [splitpt] + back.milestones\n return (front,back)","def _prepare_to_convert(coordinates: str) -> tuple:\n degrees, minutes, seconds = True, True, True\n\n if coordinates == coordinates.replace(\"°\", \" \"): degrees = False\n if coordinates == coordinates.replace(\"′\", \" \"): minutes = False\n if coordinates == coordinates.replace(\"″\", \" \"): seconds = False\n\n coordinates = coordinates.replace(\"°\", \" \").replace(\"′\", \" \").replace(\"″\", \" \").split(\" \")\n del (coordinates[-1])\n\n if seconds is False: coordinates.append(0)\n if minutes is False: coordinates.insert(0, 1)\n if degrees is False: coordinates.insert(0, 0)\n\n for i in range(len(coordinates)):\n coordinates[i] = float(coordinates[i])\n return tuple(coordinates)","def format_tuple(data):\n return \",\".join([str(item) for item in data])","def tuple_to_list(tup):\n return [element for element in tup]","def trajectory1(self):\r\n\r\n trackt = [] # particle trajectory,\r\n trackx = [] # particle trajectory\r\n an = [] # analitical s**2 + x**2 = t**2\r\n s1 = [] # s = 10; s = 0, light\r\n s2 = [] # s = 20;\r\n s3 = [] # s = 40;\r\n for i in range(0, len(self.dt.obs.obt_g)):\r\n trackt.append(float(i))\r\n trackx.append(self.dt.x[i])\r\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\r\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\r\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\r\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\r\n\r\n # plots:\r\n\r\n (fig, ax) = plt.subplots() # figsize=(7,5)\r\n\r\n # trajectory\r\n\r\n ax.plot(\r\n trackx,\r\n trackt,\r\n marker='+',\r\n linewidth=1,\r\n linestyle='-',\r\n color='green',\r\n label='treck',\r\n )\r\n\r\n # measurement t\r\n # ax.plot(self.dt.x, self.dt.t, marker=\"+\", linestyle=\" \", color=\"blue\", label=\"result of measurement\")\r\n\r\n ax.plot(\r\n self.dt.x,\r\n self.dt.t,\r\n marker='o',\r\n linestyle=' ',\r\n color='black',\r\n label='result of measurement',\r\n )\r\n\r\n # analitical t\r\n\r\n ax.plot(self.dt.x, an, linestyle='-', color='red',\r\n label='continuum')\r\n\r\n # light trajectory\r\n\r\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\r\n label='s=0 (light)')\r\n\r\n # s(x) curves\r\n\r\n ax.plot(\r\n trackx,\r\n s1,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=1.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s2,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=2.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s3,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=4.0',\r\n )\r\n\r\n # error of measurement t\r\n\r\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\r\n\r\n # signature on the horizontal x-axis\r\n\r\n ax.set_xlabel('x in metres')\r\n xm = -1.0\r\n for i in range(len(self.dt.x)):\r\n if self.dt.x[i] > xm:\r\n xm = self.dt.x[i]\r\n stepx = round(xm / float(len(self.dt.x)), 1)\r\n xm = round(xm + stepx, 1)\r\n ax.set_xlim([0.0, xm])\r\n\r\n # signature on vertical y axis\r\n\r\n ax.set_ylabel('t in metres of light time ')\r\n ym = -1.0\r\n for i in range(len(self.dt.t)):\r\n if self.dt.t[i] > ym:\r\n ym = self.dt.t[i]\r\n stepy = round(ym / float(len(self.dt.t)), 1)\r\n ym = round(ym + stepy, 1)\r\n ax.set_ylim([0.0, ym])\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\r\n\r\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.xaxis.set_major_locator(locatorx)\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\r\n\r\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.yaxis.set_major_locator(locatory)\r\n\r\n ax.grid()\r\n\r\n # show legend\r\n\r\n ax.legend(loc='upper left')\r\n\r\n # show drawing\r\n\r\n plt.show()","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def progress(adjustments):\n # intialize list\n progress = []\n # split string into list of adjustments and process individual adjustments\n for adjustment in adjustments.split(','):\n # split adjustment into year and number of minutes before midnight\n year, minutes = adjustment.split()\n # append year and representation on 24-hour clock to list\n progress.append((int(year), clock(int(minutes))))\n # convert list into tuple\n return tuple(progress)","def reshape_to_trajectory(data, trajectory_length):\n\treturn data.reshape((-1, trajectory_length*data.shape[1]))","def build(self, trajectory):\n pass","def tuple_arrivals(self):\n # Note that these are tuple arrival values for future cases and predictions themselves.\n # we shouldn't use them to validate queue sizes.\n if self.arrival_rate is None:\n self.arrival_rates()\n\n self.tuple_arrival = self.arrival_rate.copy()\n # the following converts the data back to tuple arrivals per minute\n self.tuple_arrival['num-tuples'] = self.arrival_rate['mean_arrival_rate'] * 60 * 1000\n self.tuple_arrival.drop([\"mean_arrival_rate\"], axis=1)\n return self.tuple_arrival","def create_activity_list(station,data_order):\n # Generate an ASCII representation of the GPS timestamped segments of time covered by the input data\n seglist = segmentlist(data_order.keys())\n # Sort the segment list\n seglist.sort()\n # Initialise dictionary for segment information\n full_seglist = DataQualityDict()\n # Save time span for each segment in ASCII file\n with open(\"segments.txt\", \"w\") as fout:\n for seg in seglist:\n print >>fout, \"%10.9f %10.9f\" % seg\n # FIXME: Active should be masked from the sanity channel\n full_seglist[station] = DataQualityFlag(station,active=seglist.coalesce(),known=seglist.coalesce())\n return full_seglist","def state_(state):\n return tuple( [ tuple( row ) for row in state ] )","def _maketriples_all(self):\n nholes = self.ctrs.shape[0]\n tlist = []\n for i in range(nholes):\n for j in range(nholes):\n for k in range(nholes):\n if i < j and j < k:\n tlist.append((i, j, k))\n tarray = np.array(tlist).astype(np.int)\n if self.verbose:\n print(\"tarray\", tarray.shape, \"\\n\", tarray)\n\n tname = []\n uvlist = []\n # foreach row of 3 elts...\n for triple in tarray:\n tname.append(\"{0:d}_{1:d}_{2:d}\".format(\n triple[0], triple[1], triple[2]))\n if self.verbose:\n print('triple:', triple, tname[-1])\n uvlist.append((self.ctrs[triple[0]] - self.ctrs[triple[1]],\n self.ctrs[triple[1]] - self.ctrs[triple[2]]))\n #print(len(uvlist), \"uvlist\", uvlist)\n if self.verbose:\n print(tarray.shape, np.array(uvlist).shape)\n return tarray, np.array(uvlist)","def make_taw_list(taw_tup):\n # upack\n begin_taw, end_taw, taw_step = taw_tup\n taw_list = []\n for i in range(0, ((end_taw - begin_taw) / taw_step)):\n taw = begin_taw + (i * taw_step)\n taw_list.append(taw)\n\n return taw_list","def to_list(cls, data):\n\t\tif isinstance(data, Atom) == False:\n\t\t\traise Exception(\"data must be a class object\")\n\t\tx,y,z = (data.atom_loc)[0], (data.atom_loc)[1], (data.atom_loc)[2]\n\t\treturn [x,y,z]","def group_tuplets (music_list, events):\n\n\n indices = []\n brackets = {}\n\n j = 0\n for (ev_chord, tuplet_elt, time_modification) in events:\n while (j < len (music_list)):\n if music_list[j] == ev_chord:\n break\n j += 1\n nr = 0\n if hasattr (tuplet_elt, 'number'):\n nr = getattr (tuplet_elt, 'number')\n if tuplet_elt.type == 'start':\n tuplet_object = musicxml_tuplet_to_lily (tuplet_elt, time_modification)\n tuplet_info = [j, None, tuplet_object]\n indices.append (tuplet_info)\n brackets[nr] = tuplet_info\n elif tuplet_elt.type == 'stop':\n bracket_info = brackets.get (nr, None)\n if bracket_info:\n bracket_info[1] = j # Set the ending position to j\n del brackets[nr]\n\n new_list = []\n last = 0\n for (i1, i2, tsm) in indices:\n if i1 > i2:\n continue\n\n new_list.extend (music_list[last:i1])\n seq = musicexp.SequentialMusic ()\n last = i2 + 1\n seq.elements = music_list[i1:last]\n\n tsm.element = seq\n\n new_list.append (tsm)\n #TODO: Handle nested tuplets!!!!\n\n new_list.extend (music_list[last:])\n return new_list","def makeChronList(self):\n from operator import itemgetter\n ## make list of msg lists in the format accespted by reconstructLine\n self.outData_temp = [] # this will be in chronological order\n for sens in self.outData:\n if sens is not 'header':\n for meas in self.outData[sens]:\n for time in self.outData[sens][meas]:\n value = self.outData[sens][meas][time]\n thismsg = [time, sens, meas, str(value)] # leave time as float for sorting\n self.outData_temp.append(thismsg)\n self.outData_temp.sort(key=itemgetter(0)) # sort by first index\n for msg in self.outData_temp: # now we can make time a string\n msg[0] = str(msg[0])","def convert_mtr_to_kittimot_format(data_list: List[Union[str, int, float]], frame_id: int) -> List[Union[str, int, float]]:\n annotation_list = []\n track_id = -1\n for data in data_list:\n annotation = [frame_id, -1]\n # print(\"type: \", str2id(bboxes['object_id']))\n object_type = data[0]\n truncated = -1\n occluded = -1\n alpha = -1\n bbox2d = [-1, -1, -1, -1]\n dimensions = data[1:4]\n location = data[4:7]\n rotation_y = data[7]\n\n annotation.append(object_type)\n annotation.append(truncated)\n annotation.append(occluded)\n annotation.append(alpha)\n annotation += bbox2d\n annotation += dimensions\n annotation += location\n annotation.append(rotation_y)\n annotation_list.append(annotation)\n return annotation_list\n\n\n\n \"\"\"\n convert KITTI MOTS format to AB3DMOT format\n\n \n @params:\n data_list: a list containing data in KITTI MOTs format\n \"\"\"","def print_trajectory(self, u):\n # Get the trajectory\n s = self.STL_signal(u)\n trajectory = s[0:2,:] # x and y position\n\n print(repr(trajectory))","def to_pose_2d(np_trajectory):\n arr = []\n for i in range(len(np_trajectory[0])):\n pose = msgs.Pose2D(np_trajectory[0,i], np_trajectory[1,i], 0.)\n arr.append(pose)\n return arr","def parse_lats(lines):\n class Parser:\n def __init__(self):\n self.state = 'get_utt_id'\n self.utt_id = ''\n self.out = {}\n\n def is_line_utt_id(self, splited_line):\n return len(splited_line) == 1\n\n def new_utt(self, splited_line):\n self.utt_id = splited_line[0]\n self.out[self.utt_id] = []\n self.state = 'get_arc'\n\n def start(self):\n self.state = 'get_utt_id'\n self.utt_id = ''\n self.out = {}\n\n def add(self, line):\n splited_line = line.split()\n if self.state == 'get_utt_id':\n assert self.is_line_utt_id(splited_line), RuntimeError(\"parse_lats init error.\")\n self.new_utt(splited_line)\n return\n if self.state == 'get_arc':\n # if self.is_line_utt_id(splited_line):\n # self.new_utt(splited_line)\n # else:\n if len(splited_line) == 4:\n # classic arc\n state_from, state_to, word_id = map(int, splited_line[:3])\n weight_hclg, weight_am, ali = splited_line[3].split(',')\n weight_hclg, weight_am = float(weight_hclg), float(weight_am)\n self.out[self.utt_id].append((state_from, state_to, word_id, weight_hclg, weight_am, ali))\n elif len(splited_line) == 3:\n state_from, state_to, word_id = map(int, splited_line[:3])\n weight_hclg, weight_am, ali = 0.0, 0.0, ''\n self.out[self.utt_id].append((state_from, state_to, word_id, weight_hclg, weight_am, ali))\n elif len(splited_line) == 2:\n # eos arc\n state_from = int(splited_line[0])\n weight_hclg, weight_am, ali = splited_line[1].split(',')\n weight_hclg, weight_am = float(weight_hclg), float(weight_am)\n self.out[self.utt_id].append((state_from, weight_hclg, weight_am, ali))\n elif len(splited_line) == 1:\n state_from = int(splited_line[0])\n self.out[self.utt_id].append((state_from, 0, 0, ''))\n elif len(splited_line) == 0:\n self.state = 'get_utt_id'\n else:\n raise RuntimeError(f\"parse_lats Wrong line in {self.utt_id}: {line}\")\n return\n\n def get_out(self):\n return self.out\n\n parser = Parser()\n parser.start()\n for i, line in enumerate(lines):\n parser.add(line)\n utt2lat = parser.get_out()\n return utt2lat","def build_tuple(self, t):\n comma = self.art_type([self.string_type(', ')],\n baseline=0,\n breakpoints=[1])\n repr_elems = self.concatenate(t, comma)\n return self.build_container(\n repr_elems, self.left_parenthesis, self.right_parenthesis)","def get_tuples(outputs) -> list:\n return list(map(get_tuples_helper, outputs))","def _make_list_islot_otuples_from_nodelist(self):\n if self.node_list is None:\n raise ValueError(\"`node_list` attribute undefined\")\n \n # [input sequence, LDS, prior]\n return [[('loc', 'prec')], [('prec', 'A')], [('scale',)]]","def __init__(self, length):\n self.length = length\n self.lst = []\n for x in range(length):\n for y in range(length):\n t = ((x+1, y+1), (x+1)*(y+1))\n self.lst.append(t)","def pretty(self,x):\n\n\t\t#1 - we 'decode' the chromosome recording the various times of flight (days) in the list T for convenience\n\t\tT = list([0]*(self.__n_legs))\n\n\t\tfor i in xrange(self.__n_legs):\n\t\t\tT[i] = (x[4+4*i]/sum(x[4::4]))*x[3]\n\n\t\t#2 - We compute the epochs and ephemerides of the planetary encounters\n\t\tt_P = list([None] * (self.__n_legs))\n\t\tr_P = list([None] * (self.__n_legs))\n\t\tv_P = list([None] * (self.__n_legs))\n\t\tDV = list([None] * (self.__n_legs))\n\t\tclose_d = list([None] * (self.__n_legs))\n\t\t\n\t\tfor i,planet in enumerate(self.seq):\n\t\t\tt_P[i] = epoch(x[0]+sum(T[:i+1]))\n\t\t\tr_P[i],v_P[i] = self.seq[i].eph(t_P[i])\n\n\t\t#3 - We start with the first leg: a lambert arc\n\t\ttheta = 2*pi*x[1]\n\t\tphi = acos(2*x[2]-1)-pi/2\n\t\tr = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection\n\t\tr = [JR*1000*d for d in r]\n\t\t\n\t\tl = lambert_problem(r,r_P[0],T[0]*DAY2SEC,self.common_mu, False, False)\n\n\t\t#Lambert arc to reach seq[1]\n\t\tv_end_l = l.get_v2()[0]\n\t\tv_beg_l = l.get_v1()[0]\n\t\tclose_d[0] = closest_distance(r,v_beg_l, r_P[0], v_end_l, self.common_mu)[0] / JR\n\n\t\t#First DSM occuring at the very beginning (will be cancelled by the optimizer)\n\t\tDV[0] = abs(norm(v_beg_l) - 3400)\n\n\t\tprint \"\\nFirst Leg: 1000JR to \" + self.seq[0].name \n\t\tprint \"\\tDeparture: \" + str(t_P[0]) + \" (\" + str(t_P[0].mjd2000) + \" mjd2000) \" \n\t\tprint \"\\tDuration: \" + str(T[0]) + \"days\"\n\t\tprint \"\\tInitial Velocity Increment (m/s): \" + str(DV[0])\n\t\tprint \"\\tArrival relative velocity at \" + self.seq[0].name +\" (m/s): \" + str(norm([a-b for a,b in zip(v_end_l,v_P[0])]))\n\t\tprint \"\\tClosest approach distance: \" + str(close_d[0])\n\n\t\t#4 - And we proceed with each successive leg\n\t\tfor i in xrange(1,self.__n_legs):\n\t\t\t#Fly-by \n\n\t\t\tv_out = fb_prop(v_end_l,v_P[i-1],x[6+(i-1)*4]*self.seq[i-1].radius,x[5+(i-1)*4],self.seq[i-1].mu_self)\n\t\t\t#s/c propagation before the DSM\n\t\t\tr,v = propagate_lagrangian(r_P[i-1],v_out,x[7+(i-1)*4]*T[i]*DAY2SEC,self.common_mu)\n\t\t\ttmp, ra = closest_distance(r_P[i-1],v_out, r,v, self.common_mu)\n\t\t\t#Lambert arc to reach Earth during (1-nu2)*T2 (second segment)\n\t\t\tdt = (1-x[7+(i-1)*4])*T[i]*DAY2SEC\n\t\t\tl = lambert_problem(r,r_P[i],dt,self.common_mu, False, False)\n\t\t\tv_end_l = l.get_v2()[0]\n\t\t\tv_beg_l = l.get_v1()[0]\n\t\t\ttmp2, ra2 = closest_distance(r,v_beg_l, r_P[i], v_end_l, self.common_mu)\n\t\t\tif tmp < tmp2:\n\t\t\t\tclose_d[i] = tmp/JR\n\t\t\t\tra = ra/JR\n\t\t\telse:\n\t\t\t\tclose_d[i] = tmp2/JR\n\t\t\t\tra = ra2/JR\n\t\t\t#DSM occuring at time nu2*T2\n\t\t\tDV[i] = norm([a-b for a,b in zip(v_beg_l,v)])\n\n\t\t\tprint \"\\nleg no. \" + str(i+1) + \": \" + self.seq[i-1].name + \" to \" + self.seq[i].name \n\t\t\tprint \"\\tDuration (days): \" + str(T[i])\n\t\t\tprint \"\\tFly-by epoch: \" + str(t_P[i]) + \" (\" + str(t_P[i].mjd2000) + \" mjd2000) \" \n\t\t\tprint \"\\tFly-by altitude (km): \" + str((x[6+(i-1)*4]*self.seq[i-1].radius-self.seq[i-1].radius)/1000)\n\t\t\tprint \"\\tDSM after (days): \" + str(x[7+(i-1)*4]*T[i])\n\t\t\tprint \"\\tDSM magnitude (m/s): \" + str(DV[i]) \n\t\t\tprint \"\\tClosest approach distance: \" + str(close_d[i])\n\t\t\tprint \"\\tApoapsis at closest distance: \" + str(ra)\n\t\t\tprint \"\\tV in (m/s): \" + str(v_end_l)\n\t\t\tprint \"\\tV out (m/s): \" + str(v_out)\n\t\t\n\t\t\n\t\tprint \"\\nArrival at \" + self.seq[-1].name\n\t\tvel_inf = [a-b for a,b in zip(v_end_l,v_P[-1])]\n\t\tprint \"Arrival epoch: \" + str(t_P[-1]) + \" (\" + str(t_P[-1].mjd2000) + \" mjd2000) \" \n\t\tprint \"Arrival Vinf (m/s): \" + vel_inf.__repr__() + \" - \" + str(norm(vel_inf))\n\t\tprint \"Total mission time (days): \" + str(sum(T))\n\t\tprint \"Total DV (m/s): \" + str(sum(DV))","def gen_4_tuples(it):\n\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))","def gen_4_tuples(it):\n\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))","def _covert_list_tensor_to_tuple_tensor(list_of_tensor):\n if isinstance(list_of_tensor, list):\n tuple_of_tensor = ()\n for tensor in list_of_tensor:\n tuple_of_tensor += (tensor,)\n return tuple_of_tensor\n return list_of_tensor","def __parse_move_line(self, line):\n parts = re.sub('\\(.*?\\)', '', line).split()\n x, y = None, None\n for part in parts[:0:-1]:\n axis = part.upper()[0]\n value = float(part[1:])\n if axis in ['Z', 'F']:\n parts.remove(part)\n elif axis == 'X':\n x = value\n parts.remove(part)\n elif axis == 'Y':\n y = value\n parts.remove(part)\n if x is None or y is None:\n return None\n template = parts[0] + ' X{:.6f} Y{:.6f} ' + ' '.join(parts[1:])\n return [template, x, y]","def triangulate(polyline):\n\timport p2t\n\tfrom ynlib.beziers import Point\n\n\t# Convert into p2t Points\n\tfor p in polyline:\n\t\tp = p2t.Point(p.x, p.y)\n\t\n\tcdt = p2t.CDT(polyline)\n\tp2ttriangles = cdt.triangulate()\n\t\n\ttriangles = []\n\tfor t in p2ttriangles:\n\t\ttriangles.append( (Point(t.a.x, t.a.y), Point(t.b.x, t.b.y), Point(t.c.x, t.c.y)) )\n\n\treturn triangles","def convert_obs_to_state(self, observations):\n speed = observations[0]\n distance = observations[1]\n angle = observations[2]\n\n state_converted = [speed, distance, angle]\n\n return state_converted","def coord_list_t(connected_data, t):\n coord_list = []\n for spot_id in connected_data:\n this_spot_data = connected_data[spot_id]\n row = this_spot_data[this_spot_data[:,0] == t]\n if (len(row) > 0):\n row = list(row[0])\n spot_coords = [spot_id] + row[2:5]\n coord_list.append(spot_coords)\n return coord_list","def transpositions(self):\n a = self.cyclic_form\n res = []\n for x in a:\n nx = len(x)\n if nx == 2:\n res.append(tuple(x))\n elif nx > 2:\n first = x[0]\n for y in x[nx-1:0:-1]:\n res.append((first,y))\n return res","def calcTrajPoints(trajectory_angles):\n \n traj_points = np.empty([trajectory_angles.shape[0], 3])\n tcp_origin = np.array([[0], [0], [0], [1]])\n \n \n for i in range(trajectory_angles.shape[0]):\n temp_our_angle = kf.SubstractOffsetToAngles(trajectory_angles[i])\n tmp_points = kf.CalculateDirectKinematicsTransformation(temp_our_angle, tcp_origin, 0, 7)\n traj_points[i,0] = tmp_points[0] \n traj_points[i,1] = tmp_points[1]\n traj_points[i,2] = tmp_points[2]\n \n return traj_points","def populate_weight_tuple_list(list_object):\n tuple_list = []\n\n for i in range(len(list_object[0])):\n weight_tuple = (list_object[0][i], float(list_object[1][i]))\n tuple_list.append(weight_tuple)\n \n return tuple_list","def readtrajectories(filelist, frames):\r\n filelen = len(filelist) - 2\r\n trajstart = filelen\r\n output = {}\r\n LtoeZ = []\r\n RtoeZ = []\r\n LeftToeCol = 29\r\n RightToeCol = 47\r\n for row in range(filelen):\r\n try:\r\n # Assign gait parameters to dictionary\r\n if filelist[row][0] == 'Trajectories':\r\n trajstart = row + 5\r\n except IndexError:\r\n continue\r\n output.update(tableread(filelist,trajstart,frames))\r\n sides = ['Left', 'Right']\r\n for side in sides:\r\n output[side+'StepTime'] = (frames[side+'End']-frames[side+'Start'])/100\r\n output[side+'FoffFraction'] = (frames[side+'Foff']-frames[side+'Start']) / output[side+'StepTime']\r\n try:\r\n output[side+'StepLen'] = abs(float(filelist[frames[side+'End']+trajstart][locals()[side+'ToeCol']+1]) - float(filelist[frames[side+'Start']+trajstart][locals()[side+'ToeCol']+1]))/1000\r\n except ValueError:\r\n output[side+'StepLen'] = 'NA'\r\n output[side+'SpeedCalc'] = output[side+'StepLen'] / output[side+'StepTime']\r\n #import pdb; pdb.set_trace()\r\n return output","def transform_points(Points,R,t):\r\n return [transform_point(p,R,t) for p in Points]","def _trajectory_to_multi_dof_joint_trajectory(self, p, v, a, j, s, c):\n\n msg = tm.MultiDOFJointTrajectory()\n point = tm.MultiDOFJointTrajectoryPoint()\n msg.points.append(point)\n\n #print(p)\n\n transform = gm.Transform()\n transform.translation.x = p[0]\n transform.translation.y = p[1]\n transform.translation.z = p[2]\n quaternion = tft.quaternion_from_euler(0.0, 0.0, p[3])\n transform.rotation.x = quaternion[0]\n transform.rotation.y = quaternion[1]\n transform.rotation.z = quaternion[2]\n transform.rotation.w = quaternion[3]\n point.transforms.append(transform)\n\n velocity = gm.Twist()\n velocity.linear.x = v[0]\n velocity.linear.y = v[1]\n velocity.linear.z = v[2]\n velocity.angular.z = v[3]\n point.velocities.append(velocity)\n\n acceleration = gm.Twist()\n acceleration.linear.x = a[0]\n acceleration.linear.y = a[1]\n acceleration.linear.z = a[2]\n point.accelerations.append(acceleration)\n\n return msg","def tolists(self):\n return self._times, self._values","def read_xyz_traj(filename):\n with open(filename, 'r') as traj_file:\n traj = traj_file.readlines()\n n_atoms = int(traj[0].strip()) # Get number of atoms from first line\n n_frames = int(len(traj) / (n_atoms + 2)) # Calculate number of frames (assuming n_atoms is constant)\n trajectory = {'atoms': np.empty((n_frames, n_atoms), dtype='U2'), # String of length 2\n 'coordinates': np.empty((n_frames, n_atoms, 3)), # Float\n 'headers': np.empty((n_frames,), dtype=object)} # Python object\n for frame in range(n_frames):\n start = frame * (n_atoms + 2) # Frame start\n end = (frame + 1) * (n_atoms + 2) # Frame end\n trajectory['coordinates'][frame] = [[float(i) for i in line.split()[1:4]] for line in traj[start + 2:end]]\n trajectory['atoms'][frame] = [line.split()[0] for line in traj[start + 2:end]]\n trajectory['headers'][frame] = (traj[start + 1].strip())\n return trajectory","def __wrap_with_tuple(self) -> tuple:\r\n l = list()\r\n length = len(self.data)\r\n while self.idx < length:\r\n l.append(self.__parse())\r\n return tuple(l)","def txyz_2_representation(self: Q, representation: str = \"\") -> List:\n\n symbolic = self.is_symbolic()\n\n if representation == \"\":\n rep = [self.t, self.x, self.y, self.z]\n\n elif representation == \"polar\":\n amplitude = (self.t ** 2 + self.x ** 2 + self.y ** 2 + self.z ** 2) ** (\n 1 / 2\n )\n\n abs_v = abs_of_vector(self).t\n\n if symbolic:\n theta = sp.atan2(abs_v, self.t)\n else:\n theta = math.atan2(abs_v, self.t)\n\n if abs_v == 0:\n theta_x, theta_y, theta_z = 0, 0, 0\n\n else:\n theta_x = theta * self.x / abs_v\n theta_y = theta * self.y / abs_v\n theta_z = theta * self.z / abs_v\n\n rep = [amplitude, theta_x, theta_y, theta_z]\n\n elif representation == \"spherical\":\n\n spherical_t = self.t\n\n spherical_r = (self.x ** 2 + self.y ** 2 + self.z ** 2) ** (1 / 2)\n\n if spherical_r == 0:\n theta = 0\n else:\n if symbolic:\n theta = sp.acos(self.z / spherical_r)\n\n else:\n theta = math.acos(self.z / spherical_r)\n\n if symbolic:\n phi = sp.atan2(self.y, self.x)\n else:\n phi = math.atan2(self.y, self.x)\n\n rep = [spherical_t, spherical_r, theta, phi]\n\n else:\n raise ValueError(f\"Oops, don't know representation: representation\")\n\n return rep","def make_list(sv, piece):\r\n li=[tree_build(sv,x) for x in piece.split(Comma)] # process each element RECURSIVE\r\n res=(Comma, li, None) # triplet for a list: (\",\", [list of elements], None)\r\n return res","def transforming_coordinates(self, coordinates_lists, transform): \n \n transformed_coordinates_lists = []\n for coordinates_list in coordinates_lists:\n transformed_coordinates_list = []\n for coordinate in coordinates_list:\n coordinate = tuple(coordinate)\n transformed_coordinate = list(transform(coordinate[0], coordinate[1]))\n transformed_coordinates_list.append(transformed_coordinate)\n transformed_coordinates_lists.append(transformed_coordinates_list)\n \n \n return transformed_coordinates_lists","def db_converter(self, event):\n # Splits the arr on the semicolon to separate the pairs\n arr = str(self.input.get()).strip().split(';')\n for i, entry in enumerate(arr):\n # Splits the pairs into x and y\n new_entry = tuple(map(float, entry.strip().split(\",\")))\n # Adds the new pairs back into the array\n arr[i] = new_entry\n tuple_grapher(arr)","def _sequence(game_record):\n seq = []\n for item in game_record.get_main_sequence():\n color, move = item.get_move()\n # color == None is entries that are not actual game play\n # move == None is a pass, which in theory we could try to\n # predict, but not yet\n if color is not None and move is not None:\n seq.append((color, move))\n return seq","def get_point_list(self, string):\n a = re.findall('\\(\\d+\\.\\d+, \\d+\\.\\d+\\)', string)\n lst = []\n for tp in a:\n lst.append(self.get_tuple(tp))\n print lst","def create_record_tuple(ilist):\n list_length = len(ilist)\n if list_length:\n rec_tuple = '('\n for row in list[0:list_length-1]:\n rec_tuple += str(row)\n rec_tuple += ','\n rec_tuple += str(list[list_length-1])\n rec_tuple += ')'\n else: rec_tuple = '()'\n return rec_tuple","def tuple_from_sequence(*args):\n return tuple(args)","def vec2tuple(x):\n return (x.x, x.y, x.z)","def position_trajectory(self):\n return self._read(MX_POSITION_TRAJECTORY)","def constructor(self) -> Callable[[List,List],'Trajectory']:\n return Trajectory","def _parse_coords(self):\n\n coords = []\n\n while True:\n try:\n _, x, y = self._lines.current.split()\n coords.append((float(x), float(y)))\n except ValueError:\n break\n\n try:\n next(self._lines)\n except StopIteration:\n break\n\n return coords","def _travel_times(self, trip_list, index=0):\n\n def distance_in_travel_time(dep_secs, arr_secs):\n t_dist = arr_secs - dep_secs\n if t_dist < 0:\n t_dist = self._DUMMY_SEPARATOR # min separation\n return t_dist\n\n if not trip_list:\n return []\n\n if 0 < index < len(trip_list):\n trip = trip_list[index]\n else:\n trip = trip_list[0]\n\n t_dists2 = [distance_in_travel_time(stop[3], tail[2]) for (stop, tail)\n in zip(trip.get_time_stops(), trip.get_time_stops()[1:])]\n return t_dists2","def process_timestamps(self):\n self.conn = sqlite3.connect(':memory:')\n self.cursor = self.conn.cursor()\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\n num_points = 0\n for d in gps.parse_gpx_iter(self.gpx_file):\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\n num_points += 1\n sys.stderr.write('The GPX file contained %d Points\\n' % num_points)\n self.conn.commit()","def _parse_tour(self):\n\n tour = []\n\n while True:\n try:\n s = int(self._lines.current)\n if s == -1:\n return tour\n tour.append(s)\n except ValueError:\n break\n\n try:\n next(self._lines)\n except StopIteration:\n break\n\n return tour","def make_lists(sv):\r\n \r\n mark_delayed(sv) # identify delayed objects\r\n make_pin_list(sv) # detect and initialize inputs (to false) \r\n make_old_list(sv) # create a list of used old/old \r","def convert_trace_tuples(\n trace_tuples: Sequence[TraceTuple], export_destination: str, driver: str\n) -> List[TraceTuple]:\n convert_paths: List[TraceTuple] = []\n # Iterate over datasets and save\n trace_tuple: TraceTuple\n for trace_tuple in trace_tuples:\n convert_paths.append(\n rename_trace_tuple_paths(\n trace_tuple=trace_tuple,\n export_destination=export_destination,\n driver=driver,\n )\n )\n\n return convert_paths","def to_tuple(waypoint):\n if isinstance(waypoint, dict):\n return (waypoint[\"lat\"], waypoint[\"lng\"])\n else:\n return waypoint","def ReadTrajectory(trajFile):\n trajectory=[]\n with open(trajFile, \"r\") as tF:\n line = tF.readline()\n while line is not \"\":\n #first line is number of atoms\n N = int(line.strip())\n tF.readline().strip() # second line is a comment that we throw away\n\n q = []\n for i in range(N):\n line = tF.readline().strip().split(\" \")\n for c in line[1:]:\n if c is not \"\":\n q.append(float(c))\n trajectory.append(np.array(q))\n\n line = tF.readline()\n\n return trajectory, N","def mk_lst_trans_met(self):\n\t\telem_rnge_I = [[21,30],[39,44],[46,48],[74,76],[78,80]]\n\t\telem_rnge=[]\n\t\tfor i in elem_rnge_I:\n\t\t\tel_strt=i[0]\n\t\t\tel_end=i[1]\n\t\t\trnge_sect=range(el_strt,el_end+1)\n\t\t\telem_rnge.extend(rnge_sect)\n\t\telements=[]\n\t\tfor i in elem_rnge:\n\t\t\telement=Element.from_Z(i)\t# Indice -> pymatgen element object\n\t\t\telements.append(element)\n\t\treturn elements","def tile_coordinates(text):\n UL = (text[1]), (text[2]) # Upper Left\n UR = (text[3]), (text[2]) # Upper Right\n LR = (text[3]), (text[4]) # Lower Right\n LL = (text[1]), (text[4]) # Lower Left\n coordinates = (UL, UR, LR, LL)\n return text[0], [tuple(float(x) for x in xs) for xs in coordinates]","def points (p, line: str) -> list:\n direction = line [0]\n steps = list (range (1, 1 + int (F.tail (line))))\n return F.map (point (p, direction)) (steps)","def pointListForT(x, y, type):\n\n\tpointList = []\n\n\tif x < 10:\n\t\txString = \"0%d\" % x\n\telse:\n\t\txString = \"%d\" % x\n\n\tif x < 11:\n\t\txMString = \"0%d\" % (x - 1)\n\telse:\n\t\txMString = \"%d\" % (x - 1)\n\n\tif x < 9:\n\t\txPString = \"0%d\" % (x + 1)\n\telse:\n\t\txPString = \"%d\" % (x + 1)\n\n\tif y < 11:\n\t\tyMString = \"0%d\" % (y - 1)\n\telse:\n\t\tyMString = \"%d\" % (y - 1)\n\n\tif y < 9:\n\t\tyPString = \"0%d\" % (y + 1)\n\telse:\n\t\tyPString = \"%d\" % (y + 1)\n\n\tif y < 10:\n\t\tyString = \"0%d\" % y\n\telse:\n\t\tyString = \"%d\" % y\n\n\tif type == 3:\t\t# Down\n\t\ttl = [\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\t\"%s%sTR\" % (xMString, yString)]]\n\t\ttr = [\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\t\"%s%sTL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tbl = [\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\t\"%s%sBR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sTL\" % (xString, yPString)]]\n\t\tbr = [\"%s%sBR\" % (xString, yString), 0.75, 0.75, [\t\"%s%sBL\" % (xPString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tcc = [\"%s%sCC\" % (xString, yString), 0.50, 0.50, [\t\"%s%sTL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBR\" % (xString, yString)]]\n\telif type == 4:\t\t# Left\n\t\ttl = [\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\t\"%s%sTR\" % (xMString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBL\" % (xString, yString)]]\n\t\ttr = [\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\t\"%s%sBR\" % (xString, yMString)]]\n\t\tbl = [\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\t\"%s%sTL\" % (xString, yPString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tbr = [\"%s%sBR\" % (xString, yString), 0.75, 0.75, [\t\"%s%sTR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tcc = [\"%s%sCC\" % (xString, yString), 0.50, 0.50, [\t\"%s%sTL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sTR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBL\" % (xString, yString)]]\t\n\telif type == 5:\t\t# Up\n\t\ttl = [\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\t\"%s%sTR\" % (xMString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\ttr = [\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\t\"%s%sTL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBR\" % (xString, yMString)]]\n\t\tbl = [\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\t\"%s%sBR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tbr = [\"%s%sBR\" % (xString, yString), 0.75, 0.75, [\t\"%s%sBL\" % (xPString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tcc = [\"%s%sCC\" % (xString, yString), 0.50, 0.50, [\t\"%s%sTL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sTR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBR\" % (xString, yString)]]\n\telse: # Type == 6\t# Right\n\t\ttl = [\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\t\"%s%sBL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\ttr = [\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\t\"%s%sBR\" % (xString, yMString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sCC\" % (xString, yString)]]\n\t\tbl = [\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\t\"%s%sBR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sTL\" % (xString, yPString)]]\n\t\tbr = [\"%s%sBR\" % (xString, yString), 0.75, 0.75, [\t\"%s%sBL\" % (xPString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sTR\" % (xString, yString)]]\n\t\tcc = [\"%s%sCC\" % (xString, yString), 0.50, 0.50, [\t\"%s%sTR\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBL\" % (xString, yString),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"%s%sBR\" % (xString, yString)]]\n\n\tpointList = [tl, tr, bl, br, cc]\n\n\treturn pointList","def creaLE(venta): #Esta sección fue hecha por Ángel\n listaPGA = [] # Esto genera la lista necesaria para pasarlo al archivo\n for elemento in venta:\n listaN = elemento[0] + \",\"\n listaN += str(elemento[1]) + \"\\n\"\n listaPGA.append(listaN)\n return listaPGA","def eventlist():\n\n infile = conf[\"run_path_derived\"] + 'LOCALIZED.txt'\n\n data = np.genfromtxt(infile, skip_header=1) \n\n mlt = cx.MAGtoMLT(data[:, 5], data[:, 0:5])\n\n # Swap mlat and mlon colums so in expected order (lat then long)\n data[:, [6,5]] = data[:, [5,6]]\n \n data = np.hstack((data, np.reshape(mlt, (mlt.shape[0], 1))))\n \n return data","def arrange_value_tuples(reader, point_names):\n array_for_json = []\n # Gets the time stamp and value and adds it with the point name to be added to the database\n for row in reader:\n if len(row) == 1: # End of File\n break\n timestamp = datetime.strptime(row[0] + row[1], '%m/%d/%Y%H:%M:%S')\n\n for i in range(2, len(row)):\n # Currently we are simply ignoring cases of data loss\n if row[i] != \"No Data\" and row[i] != \"Data Loss\":\n array_for_json.append([point_names[i - 1], timestamp.timestamp(), row[i]])\n\n return array_for_json","def serialize_tuple(self, obj):\n return '(' + ''.join([self.serialize(i) for i in obj]) + 't'","def plot_trajectories_XYZ(t_start,t_stop):\n \n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\n \n index_start = np.where(time == t_start)[0][0]\n index_end = np.where(time == t_stop)[0][0]\n \n time = time[index_start:index_end+1]\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\n \n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\n \n plt.figure('Trajectories')\n plt.subplot(311)\n plt.plot(time,ankle_l_trajectory[:,0])\n plt.plot(time,ankle_r_trajectory[:,0])\n #plt.title('Trajectory of the X component')\n plt.xlabel('Time [s]')\n plt.ylabel('X Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(312)\n plt.plot(time,ankle_l_trajectory[:,1])\n plt.plot(time,ankle_r_trajectory[:,1])\n #plt.title('Trajectory of the Y component')\n plt.xlabel('Time [s]')\n plt.ylabel('Y Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(313)\n plt.plot(time,ankle_l_trajectory[:,2])\n plt.plot(time,ankle_r_trajectory[:,2])\n #plt.title('Trajectory of the Z component')\n plt.xlabel('Time [s]')\n plt.ylabel('Z Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n# plt.suptitle('Decomposition of the trajectories of the hind feet')\n return"],"string":"[\n \"def parse_trajectory(path: str) -> Optional[List[Dict[str, tuple]]]:\\n lines = _get_lines_from_file(path)\\n\\n ess_file = False\\n if path.split('.')[-1] != 'xyz':\\n try:\\n log = ess_factory(fullpath=path, check_for_errors=False)\\n ess_file = True\\n except (InputError, RMGInputError):\\n ess_file = False\\n\\n if ess_file:\\n if not isinstance(log, GaussianLog):\\n raise NotImplementedError(f'Currently parse_trajectory only supports Gaussian files, got {type(log)}')\\n traj = list()\\n done = False\\n i = 0\\n while not done:\\n if i >= len(lines) or 'Normal termination of Gaussian' in lines[i] or 'Error termination via' in lines[i]:\\n done = True\\n elif 'Input orientation:' in lines[i]:\\n i += 5\\n xyz_str = ''\\n while len(lines) and '--------------------------------------------' not in lines[i]:\\n splits = lines[i].split()\\n xyz_str += f'{qcel.periodictable.to_E(int(splits[1]))} {splits[3]} {splits[4]} {splits[5]}\\\\n'\\n i += 1\\n traj.append(str_to_xyz(xyz_str))\\n i += 1\\n\\n else:\\n # this is not an ESS output file, probably an XYZ format file with several Cartesian coordinates\\n skip_line = False\\n num_of_atoms = 0\\n traj, xyz_lines = list(), list()\\n for line in lines:\\n splits = line.strip().split()\\n if len(splits) == 1 and all([c.isdigit() for c in splits[0]]):\\n if len(xyz_lines):\\n if len(xyz_lines) != num_of_atoms:\\n raise ParserError(f'Could not parse trajectory, expected {num_of_atoms} atoms, '\\n f'but got {len(xyz_lines)} for point {len(traj) + 1} in the trajectory.')\\n traj.append(str_to_xyz(''.join([xyz_line for xyz_line in xyz_lines])))\\n num_of_atoms = int(splits[0])\\n skip_line = True\\n xyz_lines = list()\\n elif skip_line:\\n # skip the comment line\\n skip_line = False\\n continue\\n else:\\n xyz_lines.append(line)\\n\\n if len(xyz_lines):\\n # add the last point in the trajectory\\n if len(xyz_lines) != num_of_atoms:\\n raise ParserError(f'Could not parse trajectory, expected {num_of_atoms} atoms, '\\n f'but got {len(xyz_lines)} for point {len(traj) + 1} in the trajectory.')\\n traj.append(str_to_xyz(''.join([xyz_line for xyz_line in xyz_lines])))\\n\\n if not len(traj):\\n logger.error(f'Could not parse trajectory from {path}')\\n return None\\n return traj\",\n \"def simulation_to_lines(data: List(Float))->List(Tuple(Int, Float)):\\n result = []\\n counter = 0\\n for payoff in data:\\n result = result + [(counter, payoff)]\\n counter+=1\\n return result\\n\\n #print(str(result))\",\n \"def trajectory(self):\\n return Trajectory.createFromTuples(self.points)\",\n \"def _print_tisserand_lists(self, Trajectory=[]):\\n\\t\\n\\timport numpy as np\\n\\t\\n\\tn = len(Trajectory);\\n\\trpl = [];\\n\\tral = [];\\n\\tpl = [];\\n\\tvinfl = [];\\n\\tfor i in range(n):\\n\\t\\tral.append(Trajectory[i][6]);\\n\\t\\trpl.append(Trajectory[i][5]);\\n\\t\\tpl.append(Trajectory[i][7]);\\n\\t\\tvinfl.append(Trajectory[i][8]);\\n\\t\\n\\tprint 'list_ra_python = [',\\n\\tn = len(ral);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % ral[i],\\n\\tprint '%f];' % ral[n-1];\\n\\t\\n\\tprint 'list_rp_python = [',\\n\\tn = len(rpl);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % rpl[i],\\n\\tprint '%f];' % rpl[n-1];\\n\\t\\n\\tprint 'list_period_python = [',\\n\\tn = len(pl);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % pl[i],\\n\\tprint '%f];' % pl[n-1];\\n\\t\\n\\tprint 'list_vinf_python = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % np.linalg.norm(vinfl[i]),\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % np.linalg.norm(vinfl[n-1]);\\n\\t\\n\\tprint 'list_vinf_python_x = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][0],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][0];\\n\\t\\n\\tprint 'list_vinf_python_y = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][1],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][1];\\n\\t\\n\\tprint 'list_vinf_python_z = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][2],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][2];\",\n \"def format_coords(self, coordinates):\\n\\n coords = []\\n for i in range(0, len(coordinates), 3):\\n coords.append(tuple(coordinates[i:i+3]))\\n\\n return coords\",\n \"def convert_shapely_points_to_tuples(list_of_points) -> list:\\n return [(p.x, p.y) for p in list_of_points]\",\n \"def get_trajectory(self) -> Tuple:\\n # Ensure index is in an allowable range\\n assert self.step <= self.num_steps\\n # TODO NOTE consider edge case: what happens if this is called right\\n # after self.cycle() has been called? does it still work?\\n\\n # ==\\n # Get the trajectory up to current timestep\\n o_traj = (self.obs_buffer[:self.step]\\n .view(-1, *self.observation_shape)) # (T, *obs_shape)\\n h_init = (self.hid_buffer[0]\\n .view(-1, self.hidden_state_dim)) # (1, hidden_dim)\\n d_traj = (self.don_buffer[:self.step]\\n .view(-1, 1)) # (T, 1)\\n a_traj = (self.act_buffer[:self.step]\\n .view(-1, self.action_dim)) # (T, action_dim)\\n\\n # Return\\n return o_traj, h_init, d_traj, a_traj\",\n \"def build(self, trajectory):\\n buf = StringIO()\\n\\n print >>buf, str(datetime.datetime.now())\\n print >>buf, '%5d' % trajectory.n_atoms\\n\\n linecount = 0\\n for atom in range(trajectory.n_atoms):\\n for dim in range(3):\\n # need to convert from nm to angstroms by multiplying by ten\\n fmt = '%12.7f' % (10 * trajectory.xyz[0, atom, dim])\\n assert len(fmt) == 12, 'fmt overflowed writing inpcrd. blowup?'\\n buf.write(fmt)\\n linecount += 1\\n if linecount >= 6:\\n buf.write(os.linesep)\\n linecount = 0\\n\\n if trajectory.unitcell_lengths != None:\\n if linecount != 0:\\n buf.write(os.linesep)\\n box = (trajectory.unitcell_lengths[0]*10).tolist()\\n box.extend(trajectory.unitcell_angles[0].tolist())\\n buf.write(('%12.7f' * 6) % tuple(box))\\n \\n return buf.getvalue()\",\n \"def process_coordinates(void: 'ChargeSystem', steps: int) -> list:\\n result = [[] for _ in void]\\n\\n for _ in range(steps):\\n for ind, charge in enumerate(void):\\n result[ind].append(list(charge.position))\\n void.update()\\n\\n return result\",\n \"def to_numpy_trajectory(trajectory):\\n tx = []\\n ty = []\\n tyaw = []\\n for pose in trajectory:\\n tx.append(pose.x)\\n ty.append(pose.y)\\n tyaw.append(pose.yaw)\\n return numpy.asarray([tx, ty, tyaw])\",\n \"def read_frame_trajectory_file( filename ):\\n file = open(filename, \\\"r\\\")\\n\\n timestamps = list()\\n path = list()\\n\\n for line in file:\\n # eliminate leading spaces\\n line = line.strip()\\n\\n # ignore comments and empty lines\\n if len(line) == 0 or line[0] == '#':\\n continue\\n\\n # divide on whitespace and convert to numbers\\n nums = [float(x) for x in line.split()]\\n \\n # separate out components and build lists\\n\\n timestamps.append( nums[0] )\\n\\n origin = list( nums[1:4] )\\n unitx = list( nums[4:7] )\\n unity = list( nums[7:10] )\\n unitz = list( nums[10:13] )\\n\\n path.append( list( (origin, unitx, unity, unitz ) ) )\\n\\n return path, timestamps\",\n \"def get_trajectory(self, sort_by: str = \\\"trials\\\") -> tuple[list[float], list[float]]:\\n raise NotImplementedError\",\n \"def dump_ue4_trajectory(name: str, trajectory: typing.Mapping[float, tf.Transform]) -> None:\\n with open('unreal_trajectory_{0}.csv'.format(name), 'w') as output_file:\\n output_file.write('Name,X,Y,Z,Roll,Pitch,Yaw\\\\n')\\n for idx, timestamp in enumerate(sorted(trajectory.keys())):\\n ue_pose = uetf.transform_to_unreal(trajectory[timestamp])\\n output_file.write('{name},{x},{y},{z},{roll},{pitch},{yaw}\\\\n'.format(\\n name=idx,\\n x=ue_pose.location[0],\\n y=ue_pose.location[1],\\n z=ue_pose.location[2],\\n roll=ue_pose.euler[0],\\n pitch=ue_pose.euler[1],\\n yaw=ue_pose.euler[2]))\",\n \"def ex_list(data):\\n return tuple(data)\",\n \"def toListOfTuple(self, df:pd.core.frame.DataFrame) -> List[Tuple]: \\n df['TIME_STAMP'] = df['TIME_STAMP'].astype('str')\\n records = df.to_records(index=False)\\n listOfTuple = list(records)\\n return listOfTuple\",\n \"def get_list(self):\\n if self.key == 'L':\\n return array_to_list([self.key, self.timing, self.data])\\n if self.key == 'T':\\n return array_to_list([self.key, self.data, self.timing])\\n tmp_data = copy.deepcopy(self.data)\\n for i in range(len(self.data)):\\n if isinstance(self.data[i], float):\\n tmp_data[i] = str('%.3f' % tmp_data[i])\\n if tmp_data[i].split('.')[1] == '000':\\n tmp_data[i] = tmp_data[i].split('.')[0]\\n return array_to_list([self.key, self.easing, self.timing, tmp_data])\",\n \"def trajectory_to_json(trajectory: Trajectory) -> str:\\n # numpy arrays need to be converted to normal tuples\\n return json.dumps(trajectory, cls=NumpyEncoder)\",\n \"def parseTupleList(self,string):\\r\\n string = string.replace(\\\"[\\\",\\\"\\\")\\r\\n string = string.replace(\\\"),\\\",\\\"*\\\")\\r\\n string = string.replace(\\\"(\\\", \\\"\\\")\\r\\n string = string.replace(\\\")\\\", \\\"\\\")\\r\\n string = string.replace(\\\"]\\\", \\\"\\\")\\r\\n string = string.split(\\\"*\\\")\\r\\n for i in xrange(len(string)):\\r\\n string[i] = string[i].split(\\\",\\\")\\r\\n for i in xrange(len(string)):\\r\\n for j in xrange(len(string[i])):\\r\\n string[i][j] = int(string[i][j])\\r\\n string[i] = tuple(string[i])\\r\\n return string\",\n \"def compute_trajectory():\\n pass\",\n \"def __str__(self):\\n out_str = \\\"\\\\n\\\".join(`\\\"%.5f, %.5f, %.1f, %s, %s\\\" % (point[0], point[1], point[2], point[3], point[4])` for point in self.__traectory_list)\\n return \\\"\\\\'x, y, altitude, capture time, capture date'\\\\n\\\"+out_str\",\n \"def parse_1d_scan_coords(path: str) -> List[Dict[str, tuple]]:\\n if not os.path.isfile(path):\\n raise InputError(f'Could not find file {path}')\\n software = identify_ess(path)\\n traj = list()\\n\\n if software == 'xtb':\\n scan_path = os.path.join(os.path.dirname(path), 'xtbscan.log')\\n if os.path.isfile(scan_path):\\n lines = _get_lines_from_file(scan_path)\\n xyz_str = ''\\n for line in lines:\\n splits = line.split()\\n if len(splits) == 1:\\n if xyz_str:\\n traj.append(str_to_xyz(xyz_str))\\n xyz_str = ''\\n continue\\n if 'energy:' in line:\\n continue\\n xyz_str += f'{qcel.periodictable.to_E(splits[0])} {splits[1]} {splits[2]} {splits[3]}\\\\n'\\n traj.append(str_to_xyz(xyz_str))\\n return traj\\n\\n lines = _get_lines_from_file(path)\\n log = ess_factory(fullpath=path, check_for_errors=False)\\n if not isinstance(log, GaussianLog):\\n raise NotImplementedError(f'Currently parse_1d_scan_coords only supports Gaussian files, got {type(log)}')\\n done = False\\n i = 0\\n while not done:\\n if i >= len(lines) or 'Normal termination of Gaussian' in lines[i] or 'Error termination via' in lines[i]:\\n done = True\\n elif 'Optimization completed' in lines[i]:\\n while i < len(lines) + 10 and 'Input orientation:' not in lines[i] or 'Forces (Hartrees/Bohr)' in lines [i + 7]:\\n i += 1\\n if 'Error termination via' in lines[i]:\\n return traj\\n i += 5\\n xyz_str, skip_traj = '', False\\n while len(lines) and '--------------------------------------------' not in lines[i]:\\n if 'DIIS: error' in lines[i]:\\n skip_traj = True\\n break\\n splits = lines[i].split()\\n xyz_str += f'{qcel.periodictable.to_E(int(splits[1]))} {splits[3]} {splits[4]} {splits[5]}\\\\n'\\n i += 1\\n if not skip_traj:\\n traj.append(str_to_xyz(xyz_str))\\n i += 1\\n return traj\",\n \"def plot_trajectory(axis, trajectory: typing.Mapping[float, tf.Transform], label: str, style: str = '-') \\\\\\n -> typing.Tuple[float, float]:\\n x = []\\n y = []\\n z = []\\n max_point = 0\\n min_point = 0\\n times = sorted(trajectory.keys())\\n first_pose = None\\n for timestamp in times:\\n pose = trajectory[timestamp]\\n if first_pose is None:\\n first_pose = pose\\n x.append(0)\\n y.append(0)\\n z.append(0)\\n else:\\n pose = first_pose.find_relative(pose)\\n max_point = max(max_point, pose.location[0], pose.location[1], pose.location[2])\\n min_point = min(min_point, pose.location[0], pose.location[1], pose.location[2])\\n x.append(pose.location[0])\\n y.append(pose.location[1])\\n z.append(pose.location[2])\\n axis.plot(x, y, z, style, label=label, alpha=0.7)\\n return min_point, max_point\",\n \"def tup_list_maker(tup_list):\\n final_list = []\\n for item in tup_list:\\n index = item[0]\\n sentences = item[1]\\n for sentence in sentences:\\n pair = (index, sentence)\\n final_list.append(pair)\\n return final_list\",\n \"def get_tuples(self):\\n pattern = list()\\n for gi in self.gradual_items:\\n temp = tuple([gi.attribute_col, gi.symbol])\\n pattern.append(temp)\\n return pattern\",\n \"def coords_to_structure(self) -> None:\\n ...\",\n \"def convert_listofrollouts(paths):\\n #print([p[\\\"observation\\\"] for p in paths[:2]])\\n observations = np.concatenate([path[\\\"observation\\\"] for path in paths])\\n actions = np.concatenate([path[\\\"action\\\"] for path in paths])\\n next_observations = np.concatenate([path[\\\"next_observation\\\"] for path in paths])\\n terminals = np.concatenate([path[\\\"terminal\\\"] for path in paths])\\n concatenated_rewards = np.concatenate([path[\\\"reward\\\"] for path in paths])\\n unconcatenated_rewards = [path[\\\"reward\\\"] for path in paths]\\n #print(\\\"DONE\\\")\\n return observations, actions, next_observations, terminals, concatenated_rewards, unconcatenated_rewards\",\n \"def toArray(parsedList):\\n interpretCommand = {\\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\\n 'L' : lambda x, prevL : x[0:2],\\n 'M' : lambda x, prevL : x[0:2],\\n 'Z' : lambda x, prevL : prevL[0],\\n }\\n\\n points =[]\\n for i,(c, arg) in enumerate(parsedList):\\n #debug('toArray ', i, c , arg)\\n newp = interpretCommand[c](arg, points)\\n points.append( newp)\\n a=numpy.array( points )\\n\\n # Some times we have points *very* close to each other\\n # these do not bring any meaning full info, so we remove them\\n #\\n x,y, w,h = computeBox(a)\\n sizeC = 0.5*(w+h)\\n #deltas = numpy.zeros((len(a),2) )\\n deltas = a[1:] - a[:-1] \\n #deltas[-1] = a[0] - a[-1]\\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\\n sortedDind = numpy.argsort(deltaD)\\n # expand longuest segments\\n nexp = int(len(deltaD)*0.9)\\n newpoints=[ None ]*len(a)\\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\\n for i,ind in enumerate(sortedDind):\\n if deltaD[ind]/sizeC<0.005: continue\\n if i>nexp:\\n np = int(deltaD[ind]/medDelta)\\n pL = [a[ind]]\\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\\n for j in range(np-1):\\n f = float(j+1)/np\\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\\n newpoints[ind] = pL\\n else:\\n newpoints[ind]=[a[ind]]\\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\\n newpoints[-1]=[a[-1]]\\n\\n points = numpy.concatenate([p for p in newpoints if p!=None] )\\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\\n ## print len(a) ,' ------> ', len(points)\\n\\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\\n\\n #return a[keep] , [ parsedList[i] for i in keep]\\n #print len(a),' ',len(points)\\n return points , []\",\n \"def build(self, trajectory):\\n #TODO Implement?\",\n \"def transform_trajectory(self, trajectory, theta):\\n origin = np.array([trajectory.s_coordinates[0],\\n trajectory.d_coordinates[0]])\\n\\n for step in range(self.t_steps):\\n point = np.array([trajectory.s_coordinates[step],\\n trajectory.d_coordinates[step]])\\n point = self._rotate_vector(point - origin, theta) + origin\\n trajectory.s_coordinates[step] = point[0]\\n trajectory.d_coordinates[step] = point[1]\\n\\n return trajectory\",\n \"def split(self, time: float) -> Tuple['Trajectory','Trajectory']:\\n if time <= self.times[0]:\\n #split before start of trajectory\\n return self.constructor()([time],[self.milestones[0]]),self.constructor()([time]+self.times,[self.milestones[0]]+self.milestones)\\n elif time >= self.times[-1]:\\n #split after end of trajectory\\n return self.constructor()(self.times+[time],self.milestones+[self.milestones[-1]]),self.constructor()([time],[self.milestones[-1]])\\n i,u = self.getSegment(time)\\n assert i >= 0,\\\"getSegment returned -1? something must be wrong with the times\\\"\\n #split in middle of trajectory\\n splitpt = self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\\n front = self.constructor()(self.times[:i+1],self.milestones[:i+1])\\n back = self.constructor()(self.times[i+1:],self.milestones[i+1:])\\n if u > 0:\\n front.times.append(time)\\n front.milestones.append(splitpt)\\n if u < 1:\\n back.times = [time] + back.times\\n back.milestones = [splitpt] + back.milestones\\n return (front,back)\",\n \"def _prepare_to_convert(coordinates: str) -> tuple:\\n degrees, minutes, seconds = True, True, True\\n\\n if coordinates == coordinates.replace(\\\"°\\\", \\\" \\\"): degrees = False\\n if coordinates == coordinates.replace(\\\"′\\\", \\\" \\\"): minutes = False\\n if coordinates == coordinates.replace(\\\"″\\\", \\\" \\\"): seconds = False\\n\\n coordinates = coordinates.replace(\\\"°\\\", \\\" \\\").replace(\\\"′\\\", \\\" \\\").replace(\\\"″\\\", \\\" \\\").split(\\\" \\\")\\n del (coordinates[-1])\\n\\n if seconds is False: coordinates.append(0)\\n if minutes is False: coordinates.insert(0, 1)\\n if degrees is False: coordinates.insert(0, 0)\\n\\n for i in range(len(coordinates)):\\n coordinates[i] = float(coordinates[i])\\n return tuple(coordinates)\",\n \"def format_tuple(data):\\n return \\\",\\\".join([str(item) for item in data])\",\n \"def tuple_to_list(tup):\\n return [element for element in tup]\",\n \"def trajectory1(self):\\r\\n\\r\\n trackt = [] # particle trajectory,\\r\\n trackx = [] # particle trajectory\\r\\n an = [] # analitical s**2 + x**2 = t**2\\r\\n s1 = [] # s = 10; s = 0, light\\r\\n s2 = [] # s = 20;\\r\\n s3 = [] # s = 40;\\r\\n for i in range(0, len(self.dt.obs.obt_g)):\\r\\n trackt.append(float(i))\\r\\n trackx.append(self.dt.x[i])\\r\\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\\r\\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\\r\\n\\r\\n # plots:\\r\\n\\r\\n (fig, ax) = plt.subplots() # figsize=(7,5)\\r\\n\\r\\n # trajectory\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n trackt,\\r\\n marker='+',\\r\\n linewidth=1,\\r\\n linestyle='-',\\r\\n color='green',\\r\\n label='treck',\\r\\n )\\r\\n\\r\\n # measurement t\\r\\n # ax.plot(self.dt.x, self.dt.t, marker=\\\"+\\\", linestyle=\\\" \\\", color=\\\"blue\\\", label=\\\"result of measurement\\\")\\r\\n\\r\\n ax.plot(\\r\\n self.dt.x,\\r\\n self.dt.t,\\r\\n marker='o',\\r\\n linestyle=' ',\\r\\n color='black',\\r\\n label='result of measurement',\\r\\n )\\r\\n\\r\\n # analitical t\\r\\n\\r\\n ax.plot(self.dt.x, an, linestyle='-', color='red',\\r\\n label='continuum')\\r\\n\\r\\n # light trajectory\\r\\n\\r\\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\\r\\n label='s=0 (light)')\\r\\n\\r\\n # s(x) curves\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n s1,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=1.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s2,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=2.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s3,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=4.0',\\r\\n )\\r\\n\\r\\n # error of measurement t\\r\\n\\r\\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\\r\\n\\r\\n # signature on the horizontal x-axis\\r\\n\\r\\n ax.set_xlabel('x in metres')\\r\\n xm = -1.0\\r\\n for i in range(len(self.dt.x)):\\r\\n if self.dt.x[i] > xm:\\r\\n xm = self.dt.x[i]\\r\\n stepx = round(xm / float(len(self.dt.x)), 1)\\r\\n xm = round(xm + stepx, 1)\\r\\n ax.set_xlim([0.0, xm])\\r\\n\\r\\n # signature on vertical y axis\\r\\n\\r\\n ax.set_ylabel('t in metres of light time ')\\r\\n ym = -1.0\\r\\n for i in range(len(self.dt.t)):\\r\\n if self.dt.t[i] > ym:\\r\\n ym = self.dt.t[i]\\r\\n stepy = round(ym / float(len(self.dt.t)), 1)\\r\\n ym = round(ym + stepy, 1)\\r\\n ax.set_ylim([0.0, ym])\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\\r\\n\\r\\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.xaxis.set_major_locator(locatorx)\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\\r\\n\\r\\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.yaxis.set_major_locator(locatory)\\r\\n\\r\\n ax.grid()\\r\\n\\r\\n # show legend\\r\\n\\r\\n ax.legend(loc='upper left')\\r\\n\\r\\n # show drawing\\r\\n\\r\\n plt.show()\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def progress(adjustments):\\n # intialize list\\n progress = []\\n # split string into list of adjustments and process individual adjustments\\n for adjustment in adjustments.split(','):\\n # split adjustment into year and number of minutes before midnight\\n year, minutes = adjustment.split()\\n # append year and representation on 24-hour clock to list\\n progress.append((int(year), clock(int(minutes))))\\n # convert list into tuple\\n return tuple(progress)\",\n \"def reshape_to_trajectory(data, trajectory_length):\\n\\treturn data.reshape((-1, trajectory_length*data.shape[1]))\",\n \"def build(self, trajectory):\\n pass\",\n \"def tuple_arrivals(self):\\n # Note that these are tuple arrival values for future cases and predictions themselves.\\n # we shouldn't use them to validate queue sizes.\\n if self.arrival_rate is None:\\n self.arrival_rates()\\n\\n self.tuple_arrival = self.arrival_rate.copy()\\n # the following converts the data back to tuple arrivals per minute\\n self.tuple_arrival['num-tuples'] = self.arrival_rate['mean_arrival_rate'] * 60 * 1000\\n self.tuple_arrival.drop([\\\"mean_arrival_rate\\\"], axis=1)\\n return self.tuple_arrival\",\n \"def create_activity_list(station,data_order):\\n # Generate an ASCII representation of the GPS timestamped segments of time covered by the input data\\n seglist = segmentlist(data_order.keys())\\n # Sort the segment list\\n seglist.sort()\\n # Initialise dictionary for segment information\\n full_seglist = DataQualityDict()\\n # Save time span for each segment in ASCII file\\n with open(\\\"segments.txt\\\", \\\"w\\\") as fout:\\n for seg in seglist:\\n print >>fout, \\\"%10.9f %10.9f\\\" % seg\\n # FIXME: Active should be masked from the sanity channel\\n full_seglist[station] = DataQualityFlag(station,active=seglist.coalesce(),known=seglist.coalesce())\\n return full_seglist\",\n \"def state_(state):\\n return tuple( [ tuple( row ) for row in state ] )\",\n \"def _maketriples_all(self):\\n nholes = self.ctrs.shape[0]\\n tlist = []\\n for i in range(nholes):\\n for j in range(nholes):\\n for k in range(nholes):\\n if i < j and j < k:\\n tlist.append((i, j, k))\\n tarray = np.array(tlist).astype(np.int)\\n if self.verbose:\\n print(\\\"tarray\\\", tarray.shape, \\\"\\\\n\\\", tarray)\\n\\n tname = []\\n uvlist = []\\n # foreach row of 3 elts...\\n for triple in tarray:\\n tname.append(\\\"{0:d}_{1:d}_{2:d}\\\".format(\\n triple[0], triple[1], triple[2]))\\n if self.verbose:\\n print('triple:', triple, tname[-1])\\n uvlist.append((self.ctrs[triple[0]] - self.ctrs[triple[1]],\\n self.ctrs[triple[1]] - self.ctrs[triple[2]]))\\n #print(len(uvlist), \\\"uvlist\\\", uvlist)\\n if self.verbose:\\n print(tarray.shape, np.array(uvlist).shape)\\n return tarray, np.array(uvlist)\",\n \"def make_taw_list(taw_tup):\\n # upack\\n begin_taw, end_taw, taw_step = taw_tup\\n taw_list = []\\n for i in range(0, ((end_taw - begin_taw) / taw_step)):\\n taw = begin_taw + (i * taw_step)\\n taw_list.append(taw)\\n\\n return taw_list\",\n \"def to_list(cls, data):\\n\\t\\tif isinstance(data, Atom) == False:\\n\\t\\t\\traise Exception(\\\"data must be a class object\\\")\\n\\t\\tx,y,z = (data.atom_loc)[0], (data.atom_loc)[1], (data.atom_loc)[2]\\n\\t\\treturn [x,y,z]\",\n \"def group_tuplets (music_list, events):\\n\\n\\n indices = []\\n brackets = {}\\n\\n j = 0\\n for (ev_chord, tuplet_elt, time_modification) in events:\\n while (j < len (music_list)):\\n if music_list[j] == ev_chord:\\n break\\n j += 1\\n nr = 0\\n if hasattr (tuplet_elt, 'number'):\\n nr = getattr (tuplet_elt, 'number')\\n if tuplet_elt.type == 'start':\\n tuplet_object = musicxml_tuplet_to_lily (tuplet_elt, time_modification)\\n tuplet_info = [j, None, tuplet_object]\\n indices.append (tuplet_info)\\n brackets[nr] = tuplet_info\\n elif tuplet_elt.type == 'stop':\\n bracket_info = brackets.get (nr, None)\\n if bracket_info:\\n bracket_info[1] = j # Set the ending position to j\\n del brackets[nr]\\n\\n new_list = []\\n last = 0\\n for (i1, i2, tsm) in indices:\\n if i1 > i2:\\n continue\\n\\n new_list.extend (music_list[last:i1])\\n seq = musicexp.SequentialMusic ()\\n last = i2 + 1\\n seq.elements = music_list[i1:last]\\n\\n tsm.element = seq\\n\\n new_list.append (tsm)\\n #TODO: Handle nested tuplets!!!!\\n\\n new_list.extend (music_list[last:])\\n return new_list\",\n \"def makeChronList(self):\\n from operator import itemgetter\\n ## make list of msg lists in the format accespted by reconstructLine\\n self.outData_temp = [] # this will be in chronological order\\n for sens in self.outData:\\n if sens is not 'header':\\n for meas in self.outData[sens]:\\n for time in self.outData[sens][meas]:\\n value = self.outData[sens][meas][time]\\n thismsg = [time, sens, meas, str(value)] # leave time as float for sorting\\n self.outData_temp.append(thismsg)\\n self.outData_temp.sort(key=itemgetter(0)) # sort by first index\\n for msg in self.outData_temp: # now we can make time a string\\n msg[0] = str(msg[0])\",\n \"def convert_mtr_to_kittimot_format(data_list: List[Union[str, int, float]], frame_id: int) -> List[Union[str, int, float]]:\\n annotation_list = []\\n track_id = -1\\n for data in data_list:\\n annotation = [frame_id, -1]\\n # print(\\\"type: \\\", str2id(bboxes['object_id']))\\n object_type = data[0]\\n truncated = -1\\n occluded = -1\\n alpha = -1\\n bbox2d = [-1, -1, -1, -1]\\n dimensions = data[1:4]\\n location = data[4:7]\\n rotation_y = data[7]\\n\\n annotation.append(object_type)\\n annotation.append(truncated)\\n annotation.append(occluded)\\n annotation.append(alpha)\\n annotation += bbox2d\\n annotation += dimensions\\n annotation += location\\n annotation.append(rotation_y)\\n annotation_list.append(annotation)\\n return annotation_list\\n\\n\\n\\n \\\"\\\"\\\"\\n convert KITTI MOTS format to AB3DMOT format\\n\\n \\n @params:\\n data_list: a list containing data in KITTI MOTs format\\n \\\"\\\"\\\"\",\n \"def print_trajectory(self, u):\\n # Get the trajectory\\n s = self.STL_signal(u)\\n trajectory = s[0:2,:] # x and y position\\n\\n print(repr(trajectory))\",\n \"def to_pose_2d(np_trajectory):\\n arr = []\\n for i in range(len(np_trajectory[0])):\\n pose = msgs.Pose2D(np_trajectory[0,i], np_trajectory[1,i], 0.)\\n arr.append(pose)\\n return arr\",\n \"def parse_lats(lines):\\n class Parser:\\n def __init__(self):\\n self.state = 'get_utt_id'\\n self.utt_id = ''\\n self.out = {}\\n\\n def is_line_utt_id(self, splited_line):\\n return len(splited_line) == 1\\n\\n def new_utt(self, splited_line):\\n self.utt_id = splited_line[0]\\n self.out[self.utt_id] = []\\n self.state = 'get_arc'\\n\\n def start(self):\\n self.state = 'get_utt_id'\\n self.utt_id = ''\\n self.out = {}\\n\\n def add(self, line):\\n splited_line = line.split()\\n if self.state == 'get_utt_id':\\n assert self.is_line_utt_id(splited_line), RuntimeError(\\\"parse_lats init error.\\\")\\n self.new_utt(splited_line)\\n return\\n if self.state == 'get_arc':\\n # if self.is_line_utt_id(splited_line):\\n # self.new_utt(splited_line)\\n # else:\\n if len(splited_line) == 4:\\n # classic arc\\n state_from, state_to, word_id = map(int, splited_line[:3])\\n weight_hclg, weight_am, ali = splited_line[3].split(',')\\n weight_hclg, weight_am = float(weight_hclg), float(weight_am)\\n self.out[self.utt_id].append((state_from, state_to, word_id, weight_hclg, weight_am, ali))\\n elif len(splited_line) == 3:\\n state_from, state_to, word_id = map(int, splited_line[:3])\\n weight_hclg, weight_am, ali = 0.0, 0.0, ''\\n self.out[self.utt_id].append((state_from, state_to, word_id, weight_hclg, weight_am, ali))\\n elif len(splited_line) == 2:\\n # eos arc\\n state_from = int(splited_line[0])\\n weight_hclg, weight_am, ali = splited_line[1].split(',')\\n weight_hclg, weight_am = float(weight_hclg), float(weight_am)\\n self.out[self.utt_id].append((state_from, weight_hclg, weight_am, ali))\\n elif len(splited_line) == 1:\\n state_from = int(splited_line[0])\\n self.out[self.utt_id].append((state_from, 0, 0, ''))\\n elif len(splited_line) == 0:\\n self.state = 'get_utt_id'\\n else:\\n raise RuntimeError(f\\\"parse_lats Wrong line in {self.utt_id}: {line}\\\")\\n return\\n\\n def get_out(self):\\n return self.out\\n\\n parser = Parser()\\n parser.start()\\n for i, line in enumerate(lines):\\n parser.add(line)\\n utt2lat = parser.get_out()\\n return utt2lat\",\n \"def build_tuple(self, t):\\n comma = self.art_type([self.string_type(', ')],\\n baseline=0,\\n breakpoints=[1])\\n repr_elems = self.concatenate(t, comma)\\n return self.build_container(\\n repr_elems, self.left_parenthesis, self.right_parenthesis)\",\n \"def get_tuples(outputs) -> list:\\n return list(map(get_tuples_helper, outputs))\",\n \"def _make_list_islot_otuples_from_nodelist(self):\\n if self.node_list is None:\\n raise ValueError(\\\"`node_list` attribute undefined\\\")\\n \\n # [input sequence, LDS, prior]\\n return [[('loc', 'prec')], [('prec', 'A')], [('scale',)]]\",\n \"def __init__(self, length):\\n self.length = length\\n self.lst = []\\n for x in range(length):\\n for y in range(length):\\n t = ((x+1, y+1), (x+1)*(y+1))\\n self.lst.append(t)\",\n \"def pretty(self,x):\\n\\n\\t\\t#1 - we 'decode' the chromosome recording the various times of flight (days) in the list T for convenience\\n\\t\\tT = list([0]*(self.__n_legs))\\n\\n\\t\\tfor i in xrange(self.__n_legs):\\n\\t\\t\\tT[i] = (x[4+4*i]/sum(x[4::4]))*x[3]\\n\\n\\t\\t#2 - We compute the epochs and ephemerides of the planetary encounters\\n\\t\\tt_P = list([None] * (self.__n_legs))\\n\\t\\tr_P = list([None] * (self.__n_legs))\\n\\t\\tv_P = list([None] * (self.__n_legs))\\n\\t\\tDV = list([None] * (self.__n_legs))\\n\\t\\tclose_d = list([None] * (self.__n_legs))\\n\\t\\t\\n\\t\\tfor i,planet in enumerate(self.seq):\\n\\t\\t\\tt_P[i] = epoch(x[0]+sum(T[:i+1]))\\n\\t\\t\\tr_P[i],v_P[i] = self.seq[i].eph(t_P[i])\\n\\n\\t\\t#3 - We start with the first leg: a lambert arc\\n\\t\\ttheta = 2*pi*x[1]\\n\\t\\tphi = acos(2*x[2]-1)-pi/2\\n\\t\\tr = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection\\n\\t\\tr = [JR*1000*d for d in r]\\n\\t\\t\\n\\t\\tl = lambert_problem(r,r_P[0],T[0]*DAY2SEC,self.common_mu, False, False)\\n\\n\\t\\t#Lambert arc to reach seq[1]\\n\\t\\tv_end_l = l.get_v2()[0]\\n\\t\\tv_beg_l = l.get_v1()[0]\\n\\t\\tclose_d[0] = closest_distance(r,v_beg_l, r_P[0], v_end_l, self.common_mu)[0] / JR\\n\\n\\t\\t#First DSM occuring at the very beginning (will be cancelled by the optimizer)\\n\\t\\tDV[0] = abs(norm(v_beg_l) - 3400)\\n\\n\\t\\tprint \\\"\\\\nFirst Leg: 1000JR to \\\" + self.seq[0].name \\n\\t\\tprint \\\"\\\\tDeparture: \\\" + str(t_P[0]) + \\\" (\\\" + str(t_P[0].mjd2000) + \\\" mjd2000) \\\" \\n\\t\\tprint \\\"\\\\tDuration: \\\" + str(T[0]) + \\\"days\\\"\\n\\t\\tprint \\\"\\\\tInitial Velocity Increment (m/s): \\\" + str(DV[0])\\n\\t\\tprint \\\"\\\\tArrival relative velocity at \\\" + self.seq[0].name +\\\" (m/s): \\\" + str(norm([a-b for a,b in zip(v_end_l,v_P[0])]))\\n\\t\\tprint \\\"\\\\tClosest approach distance: \\\" + str(close_d[0])\\n\\n\\t\\t#4 - And we proceed with each successive leg\\n\\t\\tfor i in xrange(1,self.__n_legs):\\n\\t\\t\\t#Fly-by \\n\\n\\t\\t\\tv_out = fb_prop(v_end_l,v_P[i-1],x[6+(i-1)*4]*self.seq[i-1].radius,x[5+(i-1)*4],self.seq[i-1].mu_self)\\n\\t\\t\\t#s/c propagation before the DSM\\n\\t\\t\\tr,v = propagate_lagrangian(r_P[i-1],v_out,x[7+(i-1)*4]*T[i]*DAY2SEC,self.common_mu)\\n\\t\\t\\ttmp, ra = closest_distance(r_P[i-1],v_out, r,v, self.common_mu)\\n\\t\\t\\t#Lambert arc to reach Earth during (1-nu2)*T2 (second segment)\\n\\t\\t\\tdt = (1-x[7+(i-1)*4])*T[i]*DAY2SEC\\n\\t\\t\\tl = lambert_problem(r,r_P[i],dt,self.common_mu, False, False)\\n\\t\\t\\tv_end_l = l.get_v2()[0]\\n\\t\\t\\tv_beg_l = l.get_v1()[0]\\n\\t\\t\\ttmp2, ra2 = closest_distance(r,v_beg_l, r_P[i], v_end_l, self.common_mu)\\n\\t\\t\\tif tmp < tmp2:\\n\\t\\t\\t\\tclose_d[i] = tmp/JR\\n\\t\\t\\t\\tra = ra/JR\\n\\t\\t\\telse:\\n\\t\\t\\t\\tclose_d[i] = tmp2/JR\\n\\t\\t\\t\\tra = ra2/JR\\n\\t\\t\\t#DSM occuring at time nu2*T2\\n\\t\\t\\tDV[i] = norm([a-b for a,b in zip(v_beg_l,v)])\\n\\n\\t\\t\\tprint \\\"\\\\nleg no. \\\" + str(i+1) + \\\": \\\" + self.seq[i-1].name + \\\" to \\\" + self.seq[i].name \\n\\t\\t\\tprint \\\"\\\\tDuration (days): \\\" + str(T[i])\\n\\t\\t\\tprint \\\"\\\\tFly-by epoch: \\\" + str(t_P[i]) + \\\" (\\\" + str(t_P[i].mjd2000) + \\\" mjd2000) \\\" \\n\\t\\t\\tprint \\\"\\\\tFly-by altitude (km): \\\" + str((x[6+(i-1)*4]*self.seq[i-1].radius-self.seq[i-1].radius)/1000)\\n\\t\\t\\tprint \\\"\\\\tDSM after (days): \\\" + str(x[7+(i-1)*4]*T[i])\\n\\t\\t\\tprint \\\"\\\\tDSM magnitude (m/s): \\\" + str(DV[i]) \\n\\t\\t\\tprint \\\"\\\\tClosest approach distance: \\\" + str(close_d[i])\\n\\t\\t\\tprint \\\"\\\\tApoapsis at closest distance: \\\" + str(ra)\\n\\t\\t\\tprint \\\"\\\\tV in (m/s): \\\" + str(v_end_l)\\n\\t\\t\\tprint \\\"\\\\tV out (m/s): \\\" + str(v_out)\\n\\t\\t\\n\\t\\t\\n\\t\\tprint \\\"\\\\nArrival at \\\" + self.seq[-1].name\\n\\t\\tvel_inf = [a-b for a,b in zip(v_end_l,v_P[-1])]\\n\\t\\tprint \\\"Arrival epoch: \\\" + str(t_P[-1]) + \\\" (\\\" + str(t_P[-1].mjd2000) + \\\" mjd2000) \\\" \\n\\t\\tprint \\\"Arrival Vinf (m/s): \\\" + vel_inf.__repr__() + \\\" - \\\" + str(norm(vel_inf))\\n\\t\\tprint \\\"Total mission time (days): \\\" + str(sum(T))\\n\\t\\tprint \\\"Total DV (m/s): \\\" + str(sum(DV))\",\n \"def gen_4_tuples(it):\\n\\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))\",\n \"def gen_4_tuples(it):\\n\\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))\",\n \"def _covert_list_tensor_to_tuple_tensor(list_of_tensor):\\n if isinstance(list_of_tensor, list):\\n tuple_of_tensor = ()\\n for tensor in list_of_tensor:\\n tuple_of_tensor += (tensor,)\\n return tuple_of_tensor\\n return list_of_tensor\",\n \"def __parse_move_line(self, line):\\n parts = re.sub('\\\\(.*?\\\\)', '', line).split()\\n x, y = None, None\\n for part in parts[:0:-1]:\\n axis = part.upper()[0]\\n value = float(part[1:])\\n if axis in ['Z', 'F']:\\n parts.remove(part)\\n elif axis == 'X':\\n x = value\\n parts.remove(part)\\n elif axis == 'Y':\\n y = value\\n parts.remove(part)\\n if x is None or y is None:\\n return None\\n template = parts[0] + ' X{:.6f} Y{:.6f} ' + ' '.join(parts[1:])\\n return [template, x, y]\",\n \"def triangulate(polyline):\\n\\timport p2t\\n\\tfrom ynlib.beziers import Point\\n\\n\\t# Convert into p2t Points\\n\\tfor p in polyline:\\n\\t\\tp = p2t.Point(p.x, p.y)\\n\\t\\n\\tcdt = p2t.CDT(polyline)\\n\\tp2ttriangles = cdt.triangulate()\\n\\t\\n\\ttriangles = []\\n\\tfor t in p2ttriangles:\\n\\t\\ttriangles.append( (Point(t.a.x, t.a.y), Point(t.b.x, t.b.y), Point(t.c.x, t.c.y)) )\\n\\n\\treturn triangles\",\n \"def convert_obs_to_state(self, observations):\\n speed = observations[0]\\n distance = observations[1]\\n angle = observations[2]\\n\\n state_converted = [speed, distance, angle]\\n\\n return state_converted\",\n \"def coord_list_t(connected_data, t):\\n coord_list = []\\n for spot_id in connected_data:\\n this_spot_data = connected_data[spot_id]\\n row = this_spot_data[this_spot_data[:,0] == t]\\n if (len(row) > 0):\\n row = list(row[0])\\n spot_coords = [spot_id] + row[2:5]\\n coord_list.append(spot_coords)\\n return coord_list\",\n \"def transpositions(self):\\n a = self.cyclic_form\\n res = []\\n for x in a:\\n nx = len(x)\\n if nx == 2:\\n res.append(tuple(x))\\n elif nx > 2:\\n first = x[0]\\n for y in x[nx-1:0:-1]:\\n res.append((first,y))\\n return res\",\n \"def calcTrajPoints(trajectory_angles):\\n \\n traj_points = np.empty([trajectory_angles.shape[0], 3])\\n tcp_origin = np.array([[0], [0], [0], [1]])\\n \\n \\n for i in range(trajectory_angles.shape[0]):\\n temp_our_angle = kf.SubstractOffsetToAngles(trajectory_angles[i])\\n tmp_points = kf.CalculateDirectKinematicsTransformation(temp_our_angle, tcp_origin, 0, 7)\\n traj_points[i,0] = tmp_points[0] \\n traj_points[i,1] = tmp_points[1]\\n traj_points[i,2] = tmp_points[2]\\n \\n return traj_points\",\n \"def populate_weight_tuple_list(list_object):\\n tuple_list = []\\n\\n for i in range(len(list_object[0])):\\n weight_tuple = (list_object[0][i], float(list_object[1][i]))\\n tuple_list.append(weight_tuple)\\n \\n return tuple_list\",\n \"def readtrajectories(filelist, frames):\\r\\n filelen = len(filelist) - 2\\r\\n trajstart = filelen\\r\\n output = {}\\r\\n LtoeZ = []\\r\\n RtoeZ = []\\r\\n LeftToeCol = 29\\r\\n RightToeCol = 47\\r\\n for row in range(filelen):\\r\\n try:\\r\\n # Assign gait parameters to dictionary\\r\\n if filelist[row][0] == 'Trajectories':\\r\\n trajstart = row + 5\\r\\n except IndexError:\\r\\n continue\\r\\n output.update(tableread(filelist,trajstart,frames))\\r\\n sides = ['Left', 'Right']\\r\\n for side in sides:\\r\\n output[side+'StepTime'] = (frames[side+'End']-frames[side+'Start'])/100\\r\\n output[side+'FoffFraction'] = (frames[side+'Foff']-frames[side+'Start']) / output[side+'StepTime']\\r\\n try:\\r\\n output[side+'StepLen'] = abs(float(filelist[frames[side+'End']+trajstart][locals()[side+'ToeCol']+1]) - float(filelist[frames[side+'Start']+trajstart][locals()[side+'ToeCol']+1]))/1000\\r\\n except ValueError:\\r\\n output[side+'StepLen'] = 'NA'\\r\\n output[side+'SpeedCalc'] = output[side+'StepLen'] / output[side+'StepTime']\\r\\n #import pdb; pdb.set_trace()\\r\\n return output\",\n \"def transform_points(Points,R,t):\\r\\n return [transform_point(p,R,t) for p in Points]\",\n \"def _trajectory_to_multi_dof_joint_trajectory(self, p, v, a, j, s, c):\\n\\n msg = tm.MultiDOFJointTrajectory()\\n point = tm.MultiDOFJointTrajectoryPoint()\\n msg.points.append(point)\\n\\n #print(p)\\n\\n transform = gm.Transform()\\n transform.translation.x = p[0]\\n transform.translation.y = p[1]\\n transform.translation.z = p[2]\\n quaternion = tft.quaternion_from_euler(0.0, 0.0, p[3])\\n transform.rotation.x = quaternion[0]\\n transform.rotation.y = quaternion[1]\\n transform.rotation.z = quaternion[2]\\n transform.rotation.w = quaternion[3]\\n point.transforms.append(transform)\\n\\n velocity = gm.Twist()\\n velocity.linear.x = v[0]\\n velocity.linear.y = v[1]\\n velocity.linear.z = v[2]\\n velocity.angular.z = v[3]\\n point.velocities.append(velocity)\\n\\n acceleration = gm.Twist()\\n acceleration.linear.x = a[0]\\n acceleration.linear.y = a[1]\\n acceleration.linear.z = a[2]\\n point.accelerations.append(acceleration)\\n\\n return msg\",\n \"def tolists(self):\\n return self._times, self._values\",\n \"def read_xyz_traj(filename):\\n with open(filename, 'r') as traj_file:\\n traj = traj_file.readlines()\\n n_atoms = int(traj[0].strip()) # Get number of atoms from first line\\n n_frames = int(len(traj) / (n_atoms + 2)) # Calculate number of frames (assuming n_atoms is constant)\\n trajectory = {'atoms': np.empty((n_frames, n_atoms), dtype='U2'), # String of length 2\\n 'coordinates': np.empty((n_frames, n_atoms, 3)), # Float\\n 'headers': np.empty((n_frames,), dtype=object)} # Python object\\n for frame in range(n_frames):\\n start = frame * (n_atoms + 2) # Frame start\\n end = (frame + 1) * (n_atoms + 2) # Frame end\\n trajectory['coordinates'][frame] = [[float(i) for i in line.split()[1:4]] for line in traj[start + 2:end]]\\n trajectory['atoms'][frame] = [line.split()[0] for line in traj[start + 2:end]]\\n trajectory['headers'][frame] = (traj[start + 1].strip())\\n return trajectory\",\n \"def __wrap_with_tuple(self) -> tuple:\\r\\n l = list()\\r\\n length = len(self.data)\\r\\n while self.idx < length:\\r\\n l.append(self.__parse())\\r\\n return tuple(l)\",\n \"def txyz_2_representation(self: Q, representation: str = \\\"\\\") -> List:\\n\\n symbolic = self.is_symbolic()\\n\\n if representation == \\\"\\\":\\n rep = [self.t, self.x, self.y, self.z]\\n\\n elif representation == \\\"polar\\\":\\n amplitude = (self.t ** 2 + self.x ** 2 + self.y ** 2 + self.z ** 2) ** (\\n 1 / 2\\n )\\n\\n abs_v = abs_of_vector(self).t\\n\\n if symbolic:\\n theta = sp.atan2(abs_v, self.t)\\n else:\\n theta = math.atan2(abs_v, self.t)\\n\\n if abs_v == 0:\\n theta_x, theta_y, theta_z = 0, 0, 0\\n\\n else:\\n theta_x = theta * self.x / abs_v\\n theta_y = theta * self.y / abs_v\\n theta_z = theta * self.z / abs_v\\n\\n rep = [amplitude, theta_x, theta_y, theta_z]\\n\\n elif representation == \\\"spherical\\\":\\n\\n spherical_t = self.t\\n\\n spherical_r = (self.x ** 2 + self.y ** 2 + self.z ** 2) ** (1 / 2)\\n\\n if spherical_r == 0:\\n theta = 0\\n else:\\n if symbolic:\\n theta = sp.acos(self.z / spherical_r)\\n\\n else:\\n theta = math.acos(self.z / spherical_r)\\n\\n if symbolic:\\n phi = sp.atan2(self.y, self.x)\\n else:\\n phi = math.atan2(self.y, self.x)\\n\\n rep = [spherical_t, spherical_r, theta, phi]\\n\\n else:\\n raise ValueError(f\\\"Oops, don't know representation: representation\\\")\\n\\n return rep\",\n \"def make_list(sv, piece):\\r\\n li=[tree_build(sv,x) for x in piece.split(Comma)] # process each element RECURSIVE\\r\\n res=(Comma, li, None) # triplet for a list: (\\\",\\\", [list of elements], None)\\r\\n return res\",\n \"def transforming_coordinates(self, coordinates_lists, transform): \\n \\n transformed_coordinates_lists = []\\n for coordinates_list in coordinates_lists:\\n transformed_coordinates_list = []\\n for coordinate in coordinates_list:\\n coordinate = tuple(coordinate)\\n transformed_coordinate = list(transform(coordinate[0], coordinate[1]))\\n transformed_coordinates_list.append(transformed_coordinate)\\n transformed_coordinates_lists.append(transformed_coordinates_list)\\n \\n \\n return transformed_coordinates_lists\",\n \"def db_converter(self, event):\\n # Splits the arr on the semicolon to separate the pairs\\n arr = str(self.input.get()).strip().split(';')\\n for i, entry in enumerate(arr):\\n # Splits the pairs into x and y\\n new_entry = tuple(map(float, entry.strip().split(\\\",\\\")))\\n # Adds the new pairs back into the array\\n arr[i] = new_entry\\n tuple_grapher(arr)\",\n \"def _sequence(game_record):\\n seq = []\\n for item in game_record.get_main_sequence():\\n color, move = item.get_move()\\n # color == None is entries that are not actual game play\\n # move == None is a pass, which in theory we could try to\\n # predict, but not yet\\n if color is not None and move is not None:\\n seq.append((color, move))\\n return seq\",\n \"def get_point_list(self, string):\\n a = re.findall('\\\\(\\\\d+\\\\.\\\\d+, \\\\d+\\\\.\\\\d+\\\\)', string)\\n lst = []\\n for tp in a:\\n lst.append(self.get_tuple(tp))\\n print lst\",\n \"def create_record_tuple(ilist):\\n list_length = len(ilist)\\n if list_length:\\n rec_tuple = '('\\n for row in list[0:list_length-1]:\\n rec_tuple += str(row)\\n rec_tuple += ','\\n rec_tuple += str(list[list_length-1])\\n rec_tuple += ')'\\n else: rec_tuple = '()'\\n return rec_tuple\",\n \"def tuple_from_sequence(*args):\\n return tuple(args)\",\n \"def vec2tuple(x):\\n return (x.x, x.y, x.z)\",\n \"def position_trajectory(self):\\n return self._read(MX_POSITION_TRAJECTORY)\",\n \"def constructor(self) -> Callable[[List,List],'Trajectory']:\\n return Trajectory\",\n \"def _parse_coords(self):\\n\\n coords = []\\n\\n while True:\\n try:\\n _, x, y = self._lines.current.split()\\n coords.append((float(x), float(y)))\\n except ValueError:\\n break\\n\\n try:\\n next(self._lines)\\n except StopIteration:\\n break\\n\\n return coords\",\n \"def _travel_times(self, trip_list, index=0):\\n\\n def distance_in_travel_time(dep_secs, arr_secs):\\n t_dist = arr_secs - dep_secs\\n if t_dist < 0:\\n t_dist = self._DUMMY_SEPARATOR # min separation\\n return t_dist\\n\\n if not trip_list:\\n return []\\n\\n if 0 < index < len(trip_list):\\n trip = trip_list[index]\\n else:\\n trip = trip_list[0]\\n\\n t_dists2 = [distance_in_travel_time(stop[3], tail[2]) for (stop, tail)\\n in zip(trip.get_time_stops(), trip.get_time_stops()[1:])]\\n return t_dists2\",\n \"def process_timestamps(self):\\n self.conn = sqlite3.connect(':memory:')\\n self.cursor = self.conn.cursor()\\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\\n num_points = 0\\n for d in gps.parse_gpx_iter(self.gpx_file):\\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\\n num_points += 1\\n sys.stderr.write('The GPX file contained %d Points\\\\n' % num_points)\\n self.conn.commit()\",\n \"def _parse_tour(self):\\n\\n tour = []\\n\\n while True:\\n try:\\n s = int(self._lines.current)\\n if s == -1:\\n return tour\\n tour.append(s)\\n except ValueError:\\n break\\n\\n try:\\n next(self._lines)\\n except StopIteration:\\n break\\n\\n return tour\",\n \"def make_lists(sv):\\r\\n \\r\\n mark_delayed(sv) # identify delayed objects\\r\\n make_pin_list(sv) # detect and initialize inputs (to false) \\r\\n make_old_list(sv) # create a list of used old/old \\r\",\n \"def convert_trace_tuples(\\n trace_tuples: Sequence[TraceTuple], export_destination: str, driver: str\\n) -> List[TraceTuple]:\\n convert_paths: List[TraceTuple] = []\\n # Iterate over datasets and save\\n trace_tuple: TraceTuple\\n for trace_tuple in trace_tuples:\\n convert_paths.append(\\n rename_trace_tuple_paths(\\n trace_tuple=trace_tuple,\\n export_destination=export_destination,\\n driver=driver,\\n )\\n )\\n\\n return convert_paths\",\n \"def to_tuple(waypoint):\\n if isinstance(waypoint, dict):\\n return (waypoint[\\\"lat\\\"], waypoint[\\\"lng\\\"])\\n else:\\n return waypoint\",\n \"def ReadTrajectory(trajFile):\\n trajectory=[]\\n with open(trajFile, \\\"r\\\") as tF:\\n line = tF.readline()\\n while line is not \\\"\\\":\\n #first line is number of atoms\\n N = int(line.strip())\\n tF.readline().strip() # second line is a comment that we throw away\\n\\n q = []\\n for i in range(N):\\n line = tF.readline().strip().split(\\\" \\\")\\n for c in line[1:]:\\n if c is not \\\"\\\":\\n q.append(float(c))\\n trajectory.append(np.array(q))\\n\\n line = tF.readline()\\n\\n return trajectory, N\",\n \"def mk_lst_trans_met(self):\\n\\t\\telem_rnge_I = [[21,30],[39,44],[46,48],[74,76],[78,80]]\\n\\t\\telem_rnge=[]\\n\\t\\tfor i in elem_rnge_I:\\n\\t\\t\\tel_strt=i[0]\\n\\t\\t\\tel_end=i[1]\\n\\t\\t\\trnge_sect=range(el_strt,el_end+1)\\n\\t\\t\\telem_rnge.extend(rnge_sect)\\n\\t\\telements=[]\\n\\t\\tfor i in elem_rnge:\\n\\t\\t\\telement=Element.from_Z(i)\\t# Indice -> pymatgen element object\\n\\t\\t\\telements.append(element)\\n\\t\\treturn elements\",\n \"def tile_coordinates(text):\\n UL = (text[1]), (text[2]) # Upper Left\\n UR = (text[3]), (text[2]) # Upper Right\\n LR = (text[3]), (text[4]) # Lower Right\\n LL = (text[1]), (text[4]) # Lower Left\\n coordinates = (UL, UR, LR, LL)\\n return text[0], [tuple(float(x) for x in xs) for xs in coordinates]\",\n \"def points (p, line: str) -> list:\\n direction = line [0]\\n steps = list (range (1, 1 + int (F.tail (line))))\\n return F.map (point (p, direction)) (steps)\",\n \"def pointListForT(x, y, type):\\n\\n\\tpointList = []\\n\\n\\tif x < 10:\\n\\t\\txString = \\\"0%d\\\" % x\\n\\telse:\\n\\t\\txString = \\\"%d\\\" % x\\n\\n\\tif x < 11:\\n\\t\\txMString = \\\"0%d\\\" % (x - 1)\\n\\telse:\\n\\t\\txMString = \\\"%d\\\" % (x - 1)\\n\\n\\tif x < 9:\\n\\t\\txPString = \\\"0%d\\\" % (x + 1)\\n\\telse:\\n\\t\\txPString = \\\"%d\\\" % (x + 1)\\n\\n\\tif y < 11:\\n\\t\\tyMString = \\\"0%d\\\" % (y - 1)\\n\\telse:\\n\\t\\tyMString = \\\"%d\\\" % (y - 1)\\n\\n\\tif y < 9:\\n\\t\\tyPString = \\\"0%d\\\" % (y + 1)\\n\\telse:\\n\\t\\tyPString = \\\"%d\\\" % (y + 1)\\n\\n\\tif y < 10:\\n\\t\\tyString = \\\"0%d\\\" % y\\n\\telse:\\n\\t\\tyString = \\\"%d\\\" % y\\n\\n\\tif type == 3:\\t\\t# Down\\n\\t\\ttl = [\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\t\\\"%s%sTR\\\" % (xMString, yString)]]\\n\\t\\ttr = [\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\t\\\"%s%sTL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tbl = [\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\t\\\"%s%sBR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sTL\\\" % (xString, yPString)]]\\n\\t\\tbr = [\\\"%s%sBR\\\" % (xString, yString), 0.75, 0.75, [\\t\\\"%s%sBL\\\" % (xPString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tcc = [\\\"%s%sCC\\\" % (xString, yString), 0.50, 0.50, [\\t\\\"%s%sTL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBR\\\" % (xString, yString)]]\\n\\telif type == 4:\\t\\t# Left\\n\\t\\ttl = [\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\t\\\"%s%sTR\\\" % (xMString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBL\\\" % (xString, yString)]]\\n\\t\\ttr = [\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\t\\\"%s%sBR\\\" % (xString, yMString)]]\\n\\t\\tbl = [\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\t\\\"%s%sTL\\\" % (xString, yPString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tbr = [\\\"%s%sBR\\\" % (xString, yString), 0.75, 0.75, [\\t\\\"%s%sTR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tcc = [\\\"%s%sCC\\\" % (xString, yString), 0.50, 0.50, [\\t\\\"%s%sTL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sTR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBL\\\" % (xString, yString)]]\\t\\n\\telif type == 5:\\t\\t# Up\\n\\t\\ttl = [\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\t\\\"%s%sTR\\\" % (xMString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\ttr = [\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\t\\\"%s%sTL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBR\\\" % (xString, yMString)]]\\n\\t\\tbl = [\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\t\\\"%s%sBR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tbr = [\\\"%s%sBR\\\" % (xString, yString), 0.75, 0.75, [\\t\\\"%s%sBL\\\" % (xPString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tcc = [\\\"%s%sCC\\\" % (xString, yString), 0.50, 0.50, [\\t\\\"%s%sTL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sTR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBR\\\" % (xString, yString)]]\\n\\telse: # Type == 6\\t# Right\\n\\t\\ttl = [\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\t\\\"%s%sBL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\ttr = [\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\t\\\"%s%sBR\\\" % (xString, yMString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sCC\\\" % (xString, yString)]]\\n\\t\\tbl = [\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\t\\\"%s%sBR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sTL\\\" % (xString, yPString)]]\\n\\t\\tbr = [\\\"%s%sBR\\\" % (xString, yString), 0.75, 0.75, [\\t\\\"%s%sBL\\\" % (xPString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sTR\\\" % (xString, yString)]]\\n\\t\\tcc = [\\\"%s%sCC\\\" % (xString, yString), 0.50, 0.50, [\\t\\\"%s%sTR\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBL\\\" % (xString, yString),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s%sBR\\\" % (xString, yString)]]\\n\\n\\tpointList = [tl, tr, bl, br, cc]\\n\\n\\treturn pointList\",\n \"def creaLE(venta): #Esta sección fue hecha por Ángel\\n listaPGA = [] # Esto genera la lista necesaria para pasarlo al archivo\\n for elemento in venta:\\n listaN = elemento[0] + \\\",\\\"\\n listaN += str(elemento[1]) + \\\"\\\\n\\\"\\n listaPGA.append(listaN)\\n return listaPGA\",\n \"def eventlist():\\n\\n infile = conf[\\\"run_path_derived\\\"] + 'LOCALIZED.txt'\\n\\n data = np.genfromtxt(infile, skip_header=1) \\n\\n mlt = cx.MAGtoMLT(data[:, 5], data[:, 0:5])\\n\\n # Swap mlat and mlon colums so in expected order (lat then long)\\n data[:, [6,5]] = data[:, [5,6]]\\n \\n data = np.hstack((data, np.reshape(mlt, (mlt.shape[0], 1))))\\n \\n return data\",\n \"def arrange_value_tuples(reader, point_names):\\n array_for_json = []\\n # Gets the time stamp and value and adds it with the point name to be added to the database\\n for row in reader:\\n if len(row) == 1: # End of File\\n break\\n timestamp = datetime.strptime(row[0] + row[1], '%m/%d/%Y%H:%M:%S')\\n\\n for i in range(2, len(row)):\\n # Currently we are simply ignoring cases of data loss\\n if row[i] != \\\"No Data\\\" and row[i] != \\\"Data Loss\\\":\\n array_for_json.append([point_names[i - 1], timestamp.timestamp(), row[i]])\\n\\n return array_for_json\",\n \"def serialize_tuple(self, obj):\\n return '(' + ''.join([self.serialize(i) for i in obj]) + 't'\",\n \"def plot_trajectories_XYZ(t_start,t_stop):\\n \\n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\\n \\n index_start = np.where(time == t_start)[0][0]\\n index_end = np.where(time == t_stop)[0][0]\\n \\n time = time[index_start:index_end+1]\\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\\n \\n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\\n \\n plt.figure('Trajectories')\\n plt.subplot(311)\\n plt.plot(time,ankle_l_trajectory[:,0])\\n plt.plot(time,ankle_r_trajectory[:,0])\\n #plt.title('Trajectory of the X component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('X Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(312)\\n plt.plot(time,ankle_l_trajectory[:,1])\\n plt.plot(time,ankle_r_trajectory[:,1])\\n #plt.title('Trajectory of the Y component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Y Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(313)\\n plt.plot(time,ankle_l_trajectory[:,2])\\n plt.plot(time,ankle_r_trajectory[:,2])\\n #plt.title('Trajectory of the Z component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Z Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n# plt.suptitle('Decomposition of the trajectories of the hind feet')\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60951096","0.6015128","0.5985093","0.5921288","0.5903913","0.5848871","0.5752752","0.5743873","0.5734865","0.5705948","0.56735694","0.5643993","0.55531675","0.5550036","0.55357385","0.5534374","0.550818","0.5483543","0.5480718","0.5441098","0.5439881","0.5385624","0.5363065","0.53434515","0.52942","0.5265581","0.52618796","0.52603185","0.52405906","0.5237256","0.5232832","0.52316844","0.5222555","0.5218484","0.5208251","0.5208251","0.5194154","0.5179009","0.5162729","0.51561755","0.5146933","0.51391387","0.5134398","0.5134146","0.5131708","0.5118235","0.5113096","0.51125914","0.510299","0.5097575","0.5092759","0.5082477","0.5076129","0.50754684","0.50741446","0.50705945","0.5067481","0.5067481","0.50654376","0.50638914","0.5059461","0.5057738","0.5055144","0.5050949","0.50477487","0.503841","0.5031993","0.5023962","0.5020801","0.5019163","0.50171196","0.5017068","0.50142556","0.5005651","0.4995379","0.49890795","0.49878576","0.49791577","0.49784753","0.49773502","0.49733245","0.49693894","0.4966897","0.49538574","0.494839","0.4936646","0.49298304","0.49288407","0.49267125","0.4924866","0.49207833","0.4918709","0.49144992","0.49117318","0.4908979","0.49046052","0.49021062","0.49016562","0.4890996","0.48901173"],"string":"[\n \"0.60951096\",\n \"0.6015128\",\n \"0.5985093\",\n \"0.5921288\",\n \"0.5903913\",\n \"0.5848871\",\n \"0.5752752\",\n \"0.5743873\",\n \"0.5734865\",\n \"0.5705948\",\n \"0.56735694\",\n \"0.5643993\",\n \"0.55531675\",\n \"0.5550036\",\n \"0.55357385\",\n \"0.5534374\",\n \"0.550818\",\n \"0.5483543\",\n \"0.5480718\",\n \"0.5441098\",\n \"0.5439881\",\n \"0.5385624\",\n \"0.5363065\",\n \"0.53434515\",\n \"0.52942\",\n \"0.5265581\",\n \"0.52618796\",\n \"0.52603185\",\n \"0.52405906\",\n \"0.5237256\",\n \"0.5232832\",\n \"0.52316844\",\n \"0.5222555\",\n \"0.5218484\",\n \"0.5208251\",\n \"0.5208251\",\n \"0.5194154\",\n \"0.5179009\",\n \"0.5162729\",\n \"0.51561755\",\n \"0.5146933\",\n \"0.51391387\",\n \"0.5134398\",\n \"0.5134146\",\n \"0.5131708\",\n \"0.5118235\",\n \"0.5113096\",\n \"0.51125914\",\n \"0.510299\",\n \"0.5097575\",\n \"0.5092759\",\n \"0.5082477\",\n \"0.5076129\",\n \"0.50754684\",\n \"0.50741446\",\n \"0.50705945\",\n \"0.5067481\",\n \"0.5067481\",\n \"0.50654376\",\n \"0.50638914\",\n \"0.5059461\",\n \"0.5057738\",\n \"0.5055144\",\n \"0.5050949\",\n \"0.50477487\",\n \"0.503841\",\n \"0.5031993\",\n \"0.5023962\",\n \"0.5020801\",\n \"0.5019163\",\n \"0.50171196\",\n \"0.5017068\",\n \"0.50142556\",\n \"0.5005651\",\n \"0.4995379\",\n \"0.49890795\",\n \"0.49878576\",\n \"0.49791577\",\n \"0.49784753\",\n \"0.49773502\",\n \"0.49733245\",\n \"0.49693894\",\n \"0.4966897\",\n \"0.49538574\",\n \"0.494839\",\n \"0.4936646\",\n \"0.49298304\",\n \"0.49288407\",\n \"0.49267125\",\n \"0.4924866\",\n \"0.49207833\",\n \"0.4918709\",\n \"0.49144992\",\n \"0.49117318\",\n \"0.4908979\",\n \"0.49046052\",\n \"0.49021062\",\n \"0.49016562\",\n \"0.4890996\",\n \"0.48901173\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6233229"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4195,"cells":{"query":{"kind":"string","value":"This function will be use to train model and save model for given training set."},"document":{"kind":"string","value":"def train(X_train, y_train, save_model='model.h5'):\n \n # Hyperparameters\n batch_size = 32\n epochs = 30\n learning_rate = 0.001\n \n # Loading model from model.py\n model = m(input_height=IMAGE_HEIGHT, input_width=IMAGE_WIDTH)\n \n # Plot model as image\n plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)\n \n # If trained model exist already then load first for further training\n if tf.gfile.Exists(save_model):\n model.load_weights(save_model)\n model.compile(loss='mse', optimizer=Adam(learning_rate))\n \n # Only save model which has best performed on validation set.\n # These are callbacks which are being used in \"model.fit\" call\n earlyStopping = EarlyStopping(monitor='val_loss', patience=5, verbose=1, mode='min')\n mcp_save = ModelCheckpoint('model.h5', save_best_only=True, monitor='val_loss', mode='min')\n reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, epsilon=1e-4, mode='min')\n\n # Train the model\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[earlyStopping, mcp_save, reduce_lr_loss], validation_split=0.2, shuffle=True)\n \n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def trainAndSaveModels():\n print \"\\nTraining models...\"\n\n #Use the best-performed train and test splitted data \n X_train = pickle.load(open('X_train.sav','rb'))\n X_test = pickle.load(open('X_test.sav','rb'))\n Y_train = pickle.load(open('Y_train.sav','rb'))\n \n #train models\n lassoModel = LassoPrediction(X_train, X_test, Y_train)\n forestModel = RandomForestPrediction(X_train, X_test, Y_train)\n boostingModel = GradientBoosting(X_train, X_test, Y_train)\n \n #save the modes\n pickle.dump(lassoModel,open('lasso_Model.sav','wb'))\n pickle.dump(forestModel,open('forest_Model.sav','wb'))\n pickle.dump(boostingModel,open('sgb_Model.sav','wb'))","def fit(self, train_set, train_labels, validation_set=None, validation_labels=None, restore_previous_model=False):\n\n with tf.Session() as self.tf_session:\n self._initialize_tf_utilities_and_ops(restore_previous_model)\n self._train_model(train_set, train_labels, validation_set, validation_labels)\n self.tf_saver.save(self.tf_session, self.models_dir + self.model_name)","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def train(\n model_path=\"./trained_model/\",\n model_file_name=\"model.h5\",\n training_data_path=\"./train.csv\",\n):\n config = SConfig(training_data_path=training_data_path)\n s2s = Seq2Seq(config)\n s2s.fit()\n s2s.save_model(path_to_model=model_path, model_file_name=model_file_name)","def fit_store(X, y):\n print(\"Fitting model to training set...\")\n model = pr.build_model.fit_model(X, y)\n pickle.dump(model, open(\"models/\" + \"model\" + \".pkl\", \"wb\"))","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.opt.num_epochs):\n self.run_epoch()\n if (self.epoch + 1) % self.opt.save_frequency == 0:\n self.save_model()","def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()","def train(self):\n # setup model\n self.createModel()\n self.setGenerators()\n self.buildCallbacks()\n self.printParameters()\n \n # train model\n _ = self.model.fit_generator(\n generator = self.trainGen,\n validation_data = self.validateGen,\n steps_per_epoch = self.steps_per_epoch,\n validation_steps = self.validation_steps,\n epochs = self.epochs,\n use_multiprocessing = True,\n callbacks = self.callbacks)\n # clear save paths to avoid overwriting accidentaly\n self.saveName = None","def train_model(self):\n if not self.is_exist(self.path_model_directory):\n # Then create the parent folder\n os.makedirs(self.path_model_directory)\n\n # Create a meta-data pickle for the model\n self.create_meta_data_pickle()\n\n # Necessary meta-data file must be created before starting the training. Check if the file exists\n if self.is_exist(self.path_model_metadata):\n\n # We do not need to train a model if there is already a best model for the same training exist\n try:\n self.model = load_model(self.path_best_model)\n return\n except:\n self.log_event('There is no best trained model found in the parent folder. Going with the training...')\n\n # Load the model meta-data\n self.load_model_metadata()\n self.encoding_vector_size = self.number_of_distinct_items\n\n # Iterate trough the split data for the training\n for split_number in range(self.k_split):\n split_path = f'split_{str(split_number)}/'\n split_directory = self.path_model_directory + split_path\n\n # Check the split directory is already created. If it is, then we can directly start the training by using the existing data\n if self.is_exist(split_directory):\n try:\n self.load_best_tuned_model(split_number)\n except (IndexError, FileNotFoundError):\n self.load_fold_k_data_and_fit(split_number=int(split_number))\n\n else:\n # Create a folder for the split data and prepare the data for the training\n os.makedirs(split_directory)\n\n # Create an array which will contain train features-labels and test features-labels\n train_array = np.full(4, fill_value=self.mask_value, dtype=object)\n train_index = 0\n for position, split_name in enumerate(['train_split_', 'test_split_']):\n training_features_directory = split_directory + f'{split_name}{str(split_number)}_all_training_features.data'\n training_targets_directory = split_directory + f'{split_name}{str(split_number)}_all_training_targets.data'\n fold_directory = self.path_shared_folds + f'{split_name}{str(split_number)}.fold'\n\n self.process_training_data(fold_directory=fold_directory)\n\n self.save_data_to_disk(data_to_save=self.all_features, path_to_save=training_features_directory)\n train_array[train_index] = self.all_features\n train_index += 1\n self.all_features = None # Memory Management\n\n self.save_data_to_disk(data_to_save=self.all_targets, path_to_save=training_targets_directory)\n train_array[train_index] = self.all_targets\n train_index += 1\n self.all_targets = None # Memory Management\n\n # Assign the input data to respective variables for the training\n self.train_features = train_array[0]\n self.train_targets = train_array[1]\n self.test_features = train_array[2]\n self.test_targets = train_array[3]\n del train_array\n\n self.start_hyper_parameter_tuning(split_number)\n\n self.retrieve_best_model(metric=self.hyper_parameters['metric'])","def set_train(self):\n self.model.train()","def train(self):\n self.log(f\"{self.cur_file_path}\\t\\tInfo: train method invoked!\")\n self.log(f\"{self.cur_file_path}\\t\\tInfo: training {self.model.__class__.__name__} model!\")\n\n self.model.fit(self.trainX, self.trainY)","def trainModel( self, featureTrain, classTrain):","def train_model(x_data, y_data, model_type):\n # def lr model object\n clr = None\n try:\n clr = model_list[model_type]()\n except Exception as e:\n print(e)\n # fit model\n clr.fit(x_data, y_data)\n # save model in pkl file\n try:\n joblib.dump(clr, \"model/\" + model_type + \".pkl\")\n except Exception as e:\n print(e)\n return clr","def train_full_model(X,y_train):\n scaler = MinMaxScaler()\n x_train = scaler.fit_transform(X)\n\n #chose model\n # model = RandomForestClassifier()\n model = GradientBoostingClassifier()\n\n\n #train\n print(\"train model\")\n tic = time.time()\n model.fit(x_train,y_train)\n tac = time.time()\n print(\"elapsed time\", tac-tic)\n\n #save data\n save_data(model,scaler,x_train,y_train)","def train_model_4(model, X_train, y_train, image_name):\n # Train the model\n model.fit(X_train, y_train)\n \n # Save the model\n model_file = os.path.join(OUTPUT_DIR,\n \"{}_model.joblib\".format(image_name))\n joblib.dump(model, model_file)\n \n return model, model","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.num_epochs):\n print(\"EPOHA\")\n self.run_epoch()\n print(\"SAVE MODEL\")\n self.save_model()","def model_train(data_dir,test=False):\r\n \r\n if not os.path.isdir(MODEL_DIR):\r\n os.mkdir(MODEL_DIR)\r\n\r\n if test:\r\n print(\"... test flag on\")\r\n print(\"...... subsetting data\")\r\n print(\"...... subsetting countries\")\r\n \r\n ## fetch time-series formatted data\r\n ts_data = fetch_ts(data_dir)\r\n\r\n ## train a different model for each data sets\r\n for country,df in ts_data.items():\r\n if test and country not in ['all','united_kingdom']:\r\n continue\r\n model_name = re.sub(\"\\.\",\"_\",str(MODEL_VERSION))\r\n saved_model = os.path.join(MODEL_DIR,\r\n \"sl-{}-{}.joblib\".format(country,model_name))\r\n saved_test_model = os.path.join(MODEL_DIR,\r\n \"test-{}-{}.joblib\".format(country,model_name))\r\n saved_baseline = os.path.join(BASELINE_DIR,\r\n \"b-sl-{}-{}.joblib\".format(country,model_name))\r\n saved_test_baseline = os.path.join(BASELINE_DIR,\r\n \"b-test-{}-{}.joblib\".format(country,model_name))\r\n if (test and (not os.path.isfile(saved_test_model))) or ((not test) and (not os.path.isfile(saved_model))):\r\n _model_train(df,country,test=test)\r\n if (test and (not os.path.isfile(saved_test_baseline))) or ((not test) and (not os.path.isfile(saved_baseline))):\r\n _baseline_train(df,country,test=test)","def train_model(self):\n self.logger.info('Loading the data...')\n train_data = self.load_data(split=\"train\")\n dev_data = self.load_data(split=\"dev\")\n self.config.best_model = os.path.join(self.config.output_dir,\"best_model\")\n self.logger.info('Training the model, outputdir=%s...,best_model=%s' % (self.config.output_dir,self.config.best_model))\n\n train_params = {\n \"overwrite_output_dir\" : True,\n \"reprocess_input_data\": True,\n \"learning_rate\" : self.config.learning_rate,\n \"num_train_epochs\" : self.config.num_train_epochs,\n \"train_batch_size\" : self.config.train_batch_size,\n \"eval_batch_size\" : self.config.eval_batch_size,\n \"gradient_accumulation_steps\": self.config.gradient_accumulation_steps,\n \"use_early_stopping\" : self.config.early_stopping,\n \"fp16\" : False,\n \"classification_report\" : True,\n \"evaluate_during_training\" : True,\n \"evaluate_during_training_verbose\" : True,\n \"best_model_dir\": self.config.best_model,\n \"save_model_every_epoch\" : self.config.save_model_every_epoch,\n \"save_steps\" : self.config.save_steps,\n \"save_optimizer_and_scheduler\" : self.config.save_optimizer_and_scheduler,\n \"save_best_model\": True,\n }\n\n ## train the model \n self.model.train_model(\n train_data,\n eval_data=dev_data,\n output_dir=self.config.output_dir,\n show_running_loss=False,\n args=train_params,\n )\n\n ## backing up the config and create pointer to best model \n with open(os.path.join(self.config.best_model,\"trainer_config.json\"),'w') as mconfig:\n mconfig.write(json.dumps(self.config.__dict__))\n self.config.existing_model = self.config.best_model","def train():\n import training\n\n # Ensure output directories exist\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\n os.makedirs(cfg.model_path, exist_ok=True)\n os.makedirs(cfg.log_path, exist_ok=True)\n\n # Load (standardized) input data and target values\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\n val_x, val_y, _ = _load_data(cfg.validation_set)\n\n # Try to create reproducible results\n np.random.seed(cfg.initial_seed)\n\n # Save free parameters to disk\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\n 'parameters.json'))\n\n training.train(tr_x, tr_y, val_x, val_y)","def train(self, train_set=dt.treat_data(dt.load_data(\"data/train.csv\"))):\n if self.model is None:\n return\n my_callback = keras.callbacks.callbacks.EarlyStopping(monitor='loss', min_delta=0.0, patience=1000, verbose=2,\n mode='auto', baseline=None, restore_best_weights=False)\n\n train_data, train_labels = train_set\n history = self.model.fit(x=train_data, y=train_labels, epochs=100000, batch_size=45,\n callbacks=[my_callback], verbose=2, shuffle=True)\n self.model.save(\"titanic_\" + str(time.time()) + \".h5\")\n return history","def set_model_for_train(self):\n if self.train_time is None:\n self.train_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n\n self.curr_folder = data_functions.create_path(\n self.save_path, self.train_time)\n logger.info(f\"training results will be stored in: {self.curr_folder}\")\n\n self.save_model_params()\n self.train_generator, self.val_generator = \\\n self.clarifruit_train_val_generators()\n keras_logs_path = self.set_model_checkpint()\n\n return keras_logs_path","def set_train(self):\n for m in self.models.values():\n m.train()","def train_model(self, *args, **kwargs):\n self.model.train(self.training, *args, **kwargs)","def train_and_save(self, checkpoint_dir):\n dataset = self._read_dataset(self._train_dataset_path)\n features, labels = self.get_features_and_labels(dataset)\n self._model.partial_fit(features, labels, classes=self._classes)\n checkpoint_path = self._save_model(checkpoint_dir)\n return checkpoint_path","def training(self):\n self.model.fit(self.train_x, self.train_y)","def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)","def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \n model_file=None, save_path=None):\n \n print(\"- Loading configuration...\")\n if model_name in models_default_params:\n default_params = models_default_params[model_name]\n else:\n print(\"Error: the model '{}' has not been implemented\".format(model_name))\n return\n custom_objects = default_params['custom_objects']\n patch_size = default_params['patch_size']\n if save_path is None:\n save_path = default_params['default_path']\n if os.path.isfile(save_path):\n print(\"Warning: {} is an existing file and will be overwritten.\".format(save_path))\n print(\"- Configuration loaded.\")\n \n print(\"- Loading datasets...\")\n train_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Training/RGB/\",\n y_directory = \"datasets/Potsdam/Training/Labels/\",\n patch_size = patch_size)\n val_gen = preprocess.load_dataset(batch_size, x_directory = \"datasets/Potsdam/Validation/RGB/\",\n y_directory = \"datasets/Potsdam/Validation/Labels/\",\n patch_size = patch_size)\n print(\"- Data loaded.\")\n \n print(\"- Initialising model...\")\n if(model_file is not None): # Further train existing model\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\n else: # Create new model\n if model_name == 'fcn':\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \n use_pretraining=False, freeze_base=False)\n elif model_name == 'pspnet':\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\n input_shape=patch_size)\n elif model_name == 'mobilenetv2':\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \n\n model.compile(\n optimizer = optimizers.Adam(lr = 0.00001),\n loss = losses.categorical_crossentropy,\n metrics = [metrics.categorical_accuracy]) \n model.summary() \n print(\"- Model initialised.\")\n \n tensorboard = callbacks.TensorBoard(log_dir='./logs')\n csv_logger = callbacks.CSVLogger('logs/training.csv')\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\n save_weights_only=True,\n save_best_only=True)\n \n print(\"- Starting training.\")\n model.fit_generator(\n generator=train_gen,\n steps_per_epoch=steps_per_epoch,\n epochs=epochs,\n validation_data=val_gen,\n validation_steps=validation_steps,\n # callbacks=[checkpoint, csv_logger]\n )\n print(\"- Training complete.\")\n \n model.save(save_path)\n print(\"- Model saved to {}\".format(save_path))","def train_model(self, *args, **kwargs):\n raise NotImplementedError","def train(self):\n self.emission_model(self.train_data)\n self.transition_model(self.train_data)","def train(self, dataset, model_dir):\n raise NotImplementedError","def save_trained_model(self):\n save_keras_sequential(self.model, self.RELATIVE_DATA_DIRECTORY, self.get_name())\n logger.info(f\"DQL Trader: Saved trained model\")","def train(\n self,\n training_set,\n validation_set=None,\n test_set=None,\n save_path=\"model\",\n return_state_dict: bool = False,\n **kwargs,\n ):\n # ====== General setup =======\n output_features = self.model.output_features\n\n # Only use signals when on the main thread to avoid issues with CherryPy\n # https://github.com/ludwig-ai/ludwig/issues/286\n if threading.current_thread() == threading.main_thread():\n # set the original sigint signal handler\n # as we want to restore it at the end of training\n self.original_sigint_handler = signal.getsignal(signal.SIGINT)\n signal.signal(signal.SIGINT, self.set_steps_to_1_or_quit)\n\n metrics_names = get_metric_names(output_features)\n\n # ====== Setup file names =======\n model_hyperparameters_path = None\n tensorboard_log_dir = None\n if self.is_coordinator():\n os.makedirs(save_path, exist_ok=True)\n model_hyperparameters_path = os.path.join(save_path, MODEL_HYPERPARAMETERS_FILE_NAME)\n tensorboard_log_dir = os.path.join(save_path, \"logs\")\n\n # Sync save_path across the workers\n save_path = self.distributed.broadcast_object(save_path or \"\")\n\n training_progress_tracker_path = None\n training_checkpoints_path = None\n if save_path:\n training_progress_tracker_path = os.path.join(save_path, TRAINING_PROGRESS_TRACKER_FILE_NAME)\n training_checkpoints_path = os.path.join(save_path, TRAINING_CHECKPOINTS_DIR_PATH)\n\n self.callback(\n lambda c: c.on_trainer_train_setup(self, save_path, self.is_coordinator()), coordinator_only=False\n )\n\n # ====== Setup session =======\n checkpoint_manager = None\n checkpoint = self.distributed.create_checkpoint_handle(\n dist_model=self.dist_model, model=self.model, optimizer=self.optimizer, scheduler=self.scheduler\n )\n checkpoint_manager = CheckpointManager(checkpoint, training_checkpoints_path, device=self.device)\n\n # ====== Setup Tensorboard writers =======\n train_summary_writer = None\n validation_summary_writer = None\n test_summary_writer = None\n if self.is_coordinator() and not self.skip_save_log and tensorboard_log_dir:\n train_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, TRAINING))\n if validation_set is not None and validation_set.size > 0:\n validation_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, VALIDATION))\n if test_set is not None and test_set.size > 0:\n test_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, TEST))\n\n # ================ Resume logic ================\n self.callback(lambda c: c.on_resume_training(self.is_coordinator()))\n\n should_resume = self.resume and self.resume_files_exist(\n training_progress_tracker_path, training_checkpoints_path\n )\n # make sure all workers are on the same page about resuming.\n should_resume = self.distributed.broadcast_object(should_resume, name=\"should_resume\")\n\n if should_resume:\n try:\n progress_tracker = self.resume_training_progress_tracker(training_progress_tracker_path)\n self.resume_weights_and_optimizer(training_checkpoints_path, checkpoint)\n logger.info(\"Resuming training from previous run.\")\n except Exception:\n # This may happen if model training is interrupted after the progress tracker is initialized\n # but before any real training progress is made.\n progress_tracker = get_new_progress_tracker(\n batch_size=self.batch_size,\n learning_rate=self.base_learning_rate,\n best_eval_metric_value=get_initial_validation_value(self.validation_metric),\n best_increase_batch_size_eval_metric=get_initial_validation_value(\n self.increase_batch_size_eval_metric\n ),\n output_features=output_features,\n )\n logger.info(\"Failed to resume training from previous run. Creating fresh model training run.\")\n else:\n progress_tracker = get_new_progress_tracker(\n batch_size=self.batch_size,\n learning_rate=self.base_learning_rate,\n best_eval_metric_value=get_initial_validation_value(self.validation_metric),\n best_increase_batch_size_eval_metric=get_initial_validation_value(self.increase_batch_size_eval_metric),\n output_features=output_features,\n )\n logger.info(\"Creating fresh model training run.\")\n\n # Distributed: broadcast initial variable states from rank 0 to all other processes.\n # This is necessary to ensure consistent initialization of all workers when\n # training is started with random weights or restored from a checkpoint.\n self.distributed.sync_model(self.dist_model)\n self.distributed.sync_optimizer(self.optimizer)\n self.scheduler.load_state_dict(self.distributed.broadcast_object(self.scheduler.state_dict()))\n\n # For DeepSpeed, we need to set the batch size here in case it was modfied during auto-tuning\n self.distributed.set_batch_size(self.dist_model, self.batch_size)\n\n set_random_seed(self.random_seed)\n\n try:\n with training_set.initialize_batcher(\n batch_size=self.batch_size,\n should_shuffle=self.should_shuffle,\n random_seed=self.random_seed,\n distributed=self.distributed,\n ignore_last=True,\n augmentation_pipeline=self.model.get_augmentation_pipelines(),\n ) as batcher:\n # ================ Training Loop ================\n self.total_steps = get_total_steps(self.epochs, batcher.steps_per_epoch, self.train_steps)\n\n # Get the terminal steps per checkpoint.\n final_steps_per_checkpoint = get_final_steps_per_checkpoint(\n batcher.steps_per_epoch,\n self.steps_per_checkpoint,\n self.checkpoints_per_epoch,\n self.is_coordinator(),\n )\n final_steps_per_checkpoint = min(final_steps_per_checkpoint, self.total_steps)\n early_stopping_steps = final_steps_per_checkpoint * self.early_stop\n\n # Initialize the learning rate scheduler.\n self.scheduler = LRScheduler(\n self.config.learning_rate_scheduler,\n self.optimizer,\n steps_per_checkpoint=final_steps_per_checkpoint,\n total_steps=self.total_steps,\n )\n\n if self.is_coordinator():\n logger.info(\n f\"Training for {self.total_steps} step(s), approximately \"\n f\"{int(self.total_steps / batcher.steps_per_epoch)} epoch(s).\"\n )\n if self.early_stop < 0:\n logger.info(\"Early stopping policy: None\")\n else:\n logger.info(\n f\"Early stopping policy: {self.early_stop} round(s) of evaluation, or \"\n f\"{early_stopping_steps} step(s), approximately \"\n f\"{int(early_stopping_steps / batcher.steps_per_epoch)} epoch(s).\\n\"\n )\n logger.info(f\"Starting with step {progress_tracker.steps}, epoch: {progress_tracker.epoch}\")\n\n progress_bar_config = {\n \"desc\": \"Training\",\n \"total\": self.total_steps,\n \"disable\": is_progressbar_disabled(),\n \"file\": sys.stdout,\n }\n progress_bar = LudwigProgressBar(self.report_tqdm_to_ray, progress_bar_config, self.is_coordinator())\n\n while progress_tracker.steps < self.total_steps:\n # note that batch size may change over epochs\n batcher.set_epoch(progress_tracker.epoch, progress_tracker.batch_size)\n\n # epoch init\n start_time = time.time()\n\n # Reset the metrics at the start of the next epoch\n self.dist_model.train() # Sets model to training mode.\n self.model.reset_metrics()\n\n self.callback(lambda c: c.on_epoch_start(self, progress_tracker, save_path))\n\n # Trains over a full epoch of data.\n should_break = self._train_loop(\n batcher,\n progress_tracker,\n save_path,\n train_summary_writer,\n progress_bar,\n training_set,\n validation_set,\n test_set,\n start_time,\n validation_summary_writer,\n test_summary_writer,\n model_hyperparameters_path,\n output_features,\n metrics_names,\n checkpoint_manager,\n final_steps_per_checkpoint,\n early_stopping_steps,\n )\n\n # ================ Post Training Epoch ================\n progress_tracker.epoch += 1\n self.callback(lambda c: c.on_epoch_end(self, progress_tracker, save_path))\n\n if self.is_coordinator():\n # ========== Save training progress ==========\n logger.debug(\n f\"Epoch {progress_tracker.epoch} took: \"\n f\"{time_utils.strdelta((time.time() - start_time) * 1000.0)}.\"\n )\n if not self.skip_save_progress:\n checkpoint_manager.save(progress_tracker.steps)\n if self.is_coordinator():\n progress_tracker.save(os.path.join(save_path, TRAINING_PROGRESS_TRACKER_FILE_NAME))\n\n if not self.skip_save_model and self.skip_all_evaluation:\n # All evaluation was skipped, so save the current step as the best so far.\n checkpoint_manager.save_best(progress_tracker.steps)\n\n # Early stop if needed.\n if should_break:\n break\n finally:\n # ================ Finished Training ================\n self.callback(\n lambda c: c.on_trainer_train_teardown(self, progress_tracker, save_path, self.is_coordinator()),\n coordinator_only=False,\n )\n\n if train_summary_writer is not None:\n train_summary_writer.close()\n if validation_summary_writer is not None:\n validation_summary_writer.close()\n if test_summary_writer is not None:\n test_summary_writer.close()\n\n if not self.skip_save_model and self.skip_all_evaluation:\n # All evaluation was skipped, so save the current step as the best so far.\n checkpoint_manager.save_best(progress_tracker.steps)\n\n if not self.skip_save_progress:\n checkpoint_manager.close()\n\n # Load the best weights from saved checkpoint\n state_dict = None\n if self.distributed.is_coordinator():\n if not self.skip_save_model:\n state_dict = checkpoint_manager.get_best_checkpoint_state_for_inference(self.return_device)\n if not return_state_dict:\n if self.distributed.is_model_parallel():\n # Assume the full weights cannot fit in memory on GPU\n self.model = self.model.cpu()\n _, unexpected_keys = self.model.load_state_dict(state_dict, strict=False)\n assert unexpected_keys == [], f\"Unexpected keys found in state dict: {unexpected_keys}\"\n elif return_state_dict:\n state_dict = self.model.cpu().state_dict()\n\n # When running with Ray, we only need to return the state dict, as it's faster and cheaper to send the\n # state dict over the network than to load the model state here, serialize it back to a state dict, then\n # load it back on the head node.\n return_value = self.model if not return_state_dict else state_dict\n\n # restore original sigint signal handler\n if self.original_sigint_handler and threading.current_thread() == threading.main_thread():\n signal.signal(signal.SIGINT, self.original_sigint_handler)\n\n return (\n return_value,\n progress_tracker.train_metrics,\n progress_tracker.validation_metrics,\n progress_tracker.test_metrics,\n )","def train(self, X_train, y_train):\n self.model.fit(X_train, y_train)","def train(fitted_model_filename):\n click.echo(\"Mode: training.\\n\")\n defaults = get_defaults()\n\n fitted_model_filename = add_extension(fitted_model_filename)\n\n # derive final path for fitted model as base output path for fitted models + model filename\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\n\n new_options = [\"OUTPUT.FITTED_MODEL_PATH\", fitted_model_path]\n\n boot_data = bootstrap(new_options, mode=\"train\")\n defaults = boot_data['defaults']\n\n X_train, y_train = boot_data['data']\n fitted_model = train_model(X_train, y_train, defaults)\n\n # dump fitted model\n os.makedirs(defaults.OUTPUT.FITTED_MODELS_PATH, exist_ok=True)\n save_obj(fitted_model, defaults.OUTPUT.FITTED_MODEL_PATH)","def train(self, x_data, y_data):\n for model in self.list_of_models:\n model.fit(x_data, y_data)\n self.trained_models.append(model)","def fit_model(\n model,\n trainset,\n valset,\n sensor,\n target_var,\n output_models_path,\n early_stop_patience,\n epochs,\n time_stmp_str,\n out_model_name,\n history_out_name,\n):\n train_X = trainset[\"X\"]\n train_y = trainset[\"y\"]\n\n val_X = valset[\"X\"]\n val_y = valset[\"y\"]\n\n # fit network\n # que corte despues de no mejorar mucho\n early_stopping = EarlyStopping(\n monitor=\"val_loss\",\n patience=early_stop_patience,\n verbose=1,\n mode=\"min\",\n restore_best_weights=True,\n )\n # que use el mejor modelo\n checkpoint = ModelCheckpoint(\n out_model_name, save_best_only=True, monitor=\"val_loss\", mode=\"min\", verbose=2\n )\n\n history = model.fit(\n train_X,\n train_y,\n epochs=epochs,\n validation_data=(val_X, val_y),\n verbose=1,\n shuffle=False,\n callbacks=[checkpoint, early_stopping],\n )\n\n with open(history_out_name, \"wb\") as file_pi:\n pickle.dump(history, file_pi)\n\n return load_model(out_model_name)","def train_network(self):\n if self.trainData:\n if self.verbose:\n print('Started training...')\n\n for epoch in range(135):\n pass\n # save the model\n else:\n if self.verbose:\n print('No train data available')","def train(self, training_set):\n\n lengths = [ seq.shape[0] for seq in training_set ]\n\n #preprocessing the training set to obtain the desired shape\n concatenated_set = self.preprocessing( training_set )\n\n #fitting the model\n self.model.fit(concatenated_set, lengths)\n\n return","def _set_train(self):\n\n if not self.model.__dict__['training']:\n self.model.train()","def train(self, x, t):\n for i in range(self.number_model):\n curr_model = self.all_model[i]\n curr_model.fit(x, t)","def train(self, training_set):\n self.originModel.train(training_set)\n return self","def trainAndPredict(self):\r\n print(\"train\")\r\n filename= 'finalized_model.sav'\r\n # train the algorithm on training data and predict using the testing data\r\n model = self.svc_model.fit(self.X.T, self.Y)\r\n pickle.dump(model, open(filename, 'wb'))\r\n #model = pickle.load(open(filename, 'rb'))\r\n pred1 =model.predict(self.TestSet.T)\r\n # print the accuracy score of the model\r\n print(\"LinearSVC accuracy : \", accuracy_score(self.TestSetY, pred1, normalize=True))","def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initialize logistic regression with alpha(learning rate)\r\n lg = logisticregression(C=alpha)\r\n # Train the model.\r\n lg.fit(self.training_data, self.target_data)\r\n # Save the trained model as .pkl file.\r\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\r\n print \"Estimated Parameters of Logistic Regression\"\r\n # Estimated parameters of logistic regression.\r\n print lg.get_params()","def train(\n train_sets: tuple,\n test_sets: tuple,\n input_shape: tuple = (1, 128, 128, 1),\n model_version=\"1.0.0\",\n epochs: int = 100,\n classes: int = 2,\n batch_size: int = 1,\n verbose=1,\n out_dir: str = \"saved_models\"):\n (x_train, y_train), (x_test, y_test) = train_sets, test_sets\n y_train = keras.utils.to_categorical(y_train, classes)\n y_test = keras.utils.to_categorical(y_test, classes)\n m = get_model(model_version)\n if not m:\n return\n model = m.build_model(input_shape)\n model.compile(\n loss=BinaryCrossentropy(),\n optimizer=RMSprop(learning_rate=0.0001),\n metrics=['accuracy']\n )\n saver = ModelSaver(out_dir)\n csv_logger = CSVLogger(\n \"%s/%s/log.csv\" %\n (out_dir, datetime.datetime.now().date().strftime(\"%Y_%m_%d\")),\n append=True,\n separator=','\n )\n history = model.fit(\n x_train,\n y_train,\n batch_size=batch_size,\n epochs=epochs,\n verbose=verbose,\n validation_data=(x_test, y_test),\n callbacks=[saver, csv_logger]\n )\n model.save(\"%s/%s/final.hd5\" %\n (out_dir, datetime.datetime.now().date().strftime(\"%Y_%m_%d\")))\n print(\"Model saved in %s as final.hd5\" % out_dir)\n plot_results(\n history,\n epochs,\n out_dir\n )","def train_model_3(model, X_train, y_train, X_val, y_val, image_name):\n # Train the model\n model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=100)\n \n # Save the model\n model_file = os.path.join(OUTPUT_DIR, \"{}_model.txt\".format(image_name))\n model.booster_.save_model(model_file)\n \n return model, model","def train():\n \n ## check for request data\n if not request.json:\n print(\"ERROR: API (train): did not receive request data\")\n return jsonify(False)\n\n ## set the test flag\n test = False\n if 'mode' in request.json and request.json['mode'] == 'test':\n test = True\n\n print(\"... training model\")\n model = model_train(test=test)\n print(\"... training complete\")\n\n return(jsonify(True))","def train(train_x_df, train_y_df):\n x = list(train_x_df.columns.values)\n model = build_model(len(x))\n\n os.makedirs(\"./saved_models\", exist_ok=True)\n\n cp_callback = keras.callbacks.ModelCheckpoint(\n checkpoint_path, save_weights_only=True, save_best_only=True, verbose=1\n )\n\n # first 80 percent for training\n train_x = train_x_df[1:246005]\n train_y = train_y_df[1:246005]\n\n # other 20 percent for evaluating\n eval_x = train_x_df[246006 : len(train_x_df) - 1]\n eval_y = train_y_df[246006 : len(train_y_df) - 1]\n\n # train model\n model.fit(\n train_x,\n train_y,\n epochs=epochs,\n validation_split=0.2,\n verbose=0,\n batch_size=batch_size,\n callbacks=[cp_callback],\n )\n\n print(\"done training\")\n\n # export the tensorflow model to a onnx model file\n # for loading in tfe and secure enclave\n export_to_onnx(\n x,\n model,\n \"./house_credit_default.onnx\",\n )\n\n # evaluate the model using AUC, the metric used in the kaggle competition\n loss = model.evaluate(eval_x, eval_y, batch_size=batch_size)\n\n predictions = model.predict(eval_x, batch_size=batch_size)\n auc = tf.metrics.auc(eval_y, predictions)\n\n print(\"Evaluation Loss:\", loss[0])\n print(\"Accuracy:\", loss[1])\n print(\"AUC: \", auc[0][1])","def train(model_conf:ModelConf, train_set, validation_set=None):\n model_conf.print_conf()\n\n images_placeholder = tf.placeholder(dtype=tf.float32, shape=[None, model_conf.HEIGHT*model_conf.WIDTH])\n labels_placeholder = tf.placeholder(dtype=tf.int64, shape=[None])\n model = DenseNet(model_conf, is_training=True, images=images_placeholder, labels=labels_placeholder)\n model.build_graph()\n\n summary_op = tf.summary.merge_all()\n saver = tf.train.Saver(tf.all_variables())\n\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n summary_writer = tf.summary.FileWriter(model_conf.SUMMARY_DIR, graph=sess.graph)\n\n for step in range(model_conf.NUM_STEPS):\n train_images, train_labels = train_set.next_batch()\n feed_dict = {images_placeholder: train_images,\n labels_placeholder: train_labels\n }\n start_time = time.time()\n [loss_value, acc_value, _, lr_value] = sess.run([model.loss, model.acc, model.train_op, model.learning_rate],\n feed_dict=feed_dict)\n duration = time.time() - start_time\n if step % 10 == 0:\n _print_log('training', step, loss_value, acc_value, lr_value, duration)\n\n if step % 100 == 0:\n summary_str = sess.run(summary_op, feed_dict=feed_dict)\n summary_writer.add_summary(summary_str, step)\n\n if step % 500 == 0:\n validation_images = validation_set.images\n validation_labels = validation_set.labels\n feed_dict = {\n images_placeholder: validation_images,\n labels_placeholder: validation_labels\n }\n [loss_value, acc_value] = sess.run([model.loss, model.acc], feed_dict=feed_dict)\n logger.info('(validation)loss: %f, acc: %f' % (loss_value, acc_value))\n\n if (step != 0 and step % 10000 == 0) or step + 1 == model_conf.NUM_STEPS:\n checkpoint_path = os.path.join(model_conf.MODEL_SAVER_DIR, 'model.ckpt')\n saver.save(sess, checkpoint_path, step)","def _train_model(self):\n raise NotImplementedError()","def train_model(self, save_folder: str = \"latest_model\"):\n dataset_folder = self.dataset_config[\"dataset_folder\"]\n if not path.exists(dataset_folder):\n raise ValueError(f\"Folder {dataset_folder} is not exists\")\n\n files_list = [path.join(dataset_folder, f) for f in listdir(dataset_folder) if path.isfile(path.join(dataset_folder, f)) and f.endswith(\".yml\")]\n\n df, _, _, synonym_dict = make_dataframe(files=files_list)\n\n self.synonym_dict.update(synonym_dict)\n self.config[\"model\"][\"synonym\"] = self.synonym_dict\n\n dataset = DIETClassifierDataset(dataframe=df, tokenizer=self.tokenizer, entities=self.entities[1:], intents=self.intents)\n\n trainer = DIETTrainer(model=self.model, dataset=dataset,\n train_range=self.training_config[\"train_range\"],\n num_train_epochs=self.training_config[\"num_train_epochs\"],\n per_device_train_batch_size=self.training_config[\"per_device_train_batch_size\"],\n per_device_eval_batch_size=self.training_config[\"per_device_eval_batch_size\"],\n warmup_steps=self.training_config[\"warmup_steps\"],\n weight_decay=self.training_config[\"weight_decay\"],\n logging_dir=self.training_config[\"logging_dir\"],\n early_stopping_patience=self.training_config[\"early_stopping_patience\"],\n early_stopping_threshold=self.training_config[\"early_stopping_threshold\"],\n output_dir=self.training_config[\"output_dir\"])\n\n trainer.train()\n\n self.save_pretrained(directory=save_folder)","def trainModel(self, train_set_path, test_set_path, img_shape, output_dir, batch_size=32, num_epochs=25):\n\n train_datagen = ImageDataGenerator(\n # Random transform - Data augmenting\n rescale=1. / 255,\n shear_range=0.2,\n zoom_range=0.2,\n horizontal_flip=True)\n\n test_datagen = ImageDataGenerator(rescale=1. / 255)\n\n training_set = train_datagen.flow_from_directory(\n train_set_path,\n target_size=(img_shape, img_shape),\n batch_size=32,\n class_mode='categorical')\n\n test_set = test_datagen.flow_from_directory(\n test_set_path,\n target_size=(img_shape, img_shape),\n batch_size=batch_size,\n class_mode='categorical')\n\n\n # Saves the model weights after each epoch if the validation loss decreased\n now = datetime.now()\n nowstr = 'CNN_Model'\n\n now = os.path.join(output_dir, nowstr)\n\n # Make the directory\n os.makedirs(now, exist_ok = True)\n\n # Create callbacks\n savepath = os.path.join(now, 'CNN_Model.h5')\n checkpointer = ModelCheckpoint(filepath=savepath, monitor='val_acc', mode='max', verbose=0, save_best_only=True)\n fout = open(os.path.join(now, 'labels.txt'), 'wt')\n\n # Write labels to file\n for key, val in training_set.class_indices.items():\n fout.write(str(key + '\\n'))\n\n self.model.fit_generator(\n training_set,\n steps_per_epoch=len(training_set.filenames) // batch_size,\n epochs=num_epochs,\n validation_data=test_set,\n validation_steps=len(test_set.filenames) // batch_size,\n callbacks=[checkpointer])","def train_model():\n # Decode the request\n data = request.data.decode(\"utf-8\")\n\n # Write data from the request in a local csv file\n train_csv = \"train_local.csv\"\n f = open(train_csv, \"w\", encoding=\"utf-8\")\n f.write(data)\n f.close()\n\n # Load the train csv file as a DataFrame\n train_df = pd.read_csv(train_csv)\n\n # Train model\n model.train_model(train_df)\n\n return jsonify({\"success\": \"The model was trained sucessfully\"})","def fit(self,X_train,y_train):\r\n \r\n self.X_train_data=X_train.reset_index(drop=True)\r\n self.y_train_data=y_train.reset_index(drop=True)\r\n \r\n temp_fitted_model=[]\r\n for each_model in self.model_list:\r\n each_model.fit(self.X_train_data,self.y_train_data)\r\n temp_fitted_model.append(each_model)\r\n \r\n self.fitted_model=temp_fitted_model","def training(self):\n \n best_valid_loss = np.inf\n c = 0\n \n self.train_loader, self.test_loader = self.get_train_test_loaders()\n \n print('Training the {} model with the following architecture:'.format(self.model_name))\n print(summary(self.model, (3, self.image_width, self.image_height)))\n print('*'*100)\n print('Starting the training...')\n print('*'*100)\n \n # Create the model save dir if it already doesn't exist\n if not os.path.exists(self.model_save_dir):\n os.makedirs(self.model_save_dir)\n \n for epoch in range(self.n_epochs):\n\n print(f'Epoch: {epoch+1:02}')\n\n start_time = time.time()\n\n train_loss = self.train(self.train_loader)\n valid_loss = self.evaluate(self.test_loader)\n\n epoch_mins, epoch_secs = self.epoch_time(start_time, time.time())\n\n c+=1\n if valid_loss < best_valid_loss:\n best_valid_loss = valid_loss\n torch.save(self.model.state_dict(), os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)))\n c=0\n\n if c>4:\n #decrease lr if loss does not decrease after 5 steps\n self.scheduler.step()\n c=0\n\n print(f'Time: {epoch_mins}m {epoch_secs}s') \n print(f'Train Loss: {train_loss:.3f}')\n print(f'Val Loss: {valid_loss:.3f}')\n print('-'*60)\n print('The best validation loss is', best_valid_loss)\n print('*'*100)","def train_model(self,model):\r\n \r\n train_state = {'stop_early': False,\r\n 'early_stopping_step': 0,\r\n 'early_stopping_best_val': 1e8,\r\n 'learning_rate': self.lr,\r\n 'epoch_index': 0,\r\n 'train_loss': [],\r\n 'val_loss': [],\r\n 'best_model':model}\r\n \r\n dataset = self.dataset\r\n loss_fn = self.loss_fn\r\n \r\n dataset.set_split('train')\r\n print(\"Training module with \"+str(len(dataset))+\" examples\")\r\n \r\n data_loader = DataLoader(dataset,batch_size=self.batch_size,shuffle=True,\r\n drop_last=True)\r\n \r\n optimizer = optim.Adam(model.parameters(), lr=self.lr)\r\n \r\n for epoch in range(self.epochs):\r\n train_state['epoch_index'] = epoch\r\n #First step in each epoch is to train over all batches\r\n model.train()\r\n dataset.set_split('train')\r\n train_loss = 0\r\n for b_i,batch_data in enumerate(data_loader):\r\n #Step 1: zero gradients\r\n optimizer.zero_grad()\r\n #Step 2: run forward\r\n X = batch_data['x']\r\n output = model(X)\r\n #Step 3: compute loss\r\n target = batch_data['y']\r\n loss = loss_fn(output,target)\r\n #Step 4: run backward\r\n loss.backward()\r\n #Step 5: update\r\n optimizer.step()\r\n \r\n #Record accumulated loss\r\n new_loss = loss.item()\r\n train_loss += new_loss\r\n \r\n train_loss /= b_i\r\n train_state['train_loss'].append(train_loss)\r\n \r\n #After training, compute loss on validation set and check for early stop\r\n model.eval()\r\n dataset.set_split('val')\r\n val_loss = 0\r\n for b_i,batch_data in enumerate(data_loader):\r\n #Step 1: run forward\r\n X = batch_data['x']\r\n output = model(X)\r\n #Step 2: compute loss\r\n target = batch_data['y']\r\n loss = loss_fn(output,target)\r\n \r\n #Record accumulated loss\r\n new_loss = loss.item()\r\n val_loss += new_loss\r\n \r\n val_loss /= b_i\r\n train_state['val_loss'].append(val_loss)\r\n \r\n print(\"Finished epoch \"+str(epoch+1)+\". Train loss=\"+\\\r\n str(train_loss)+\", Val loss=\"+str(val_loss))\r\n \r\n if val_loss < train_state['early_stopping_best_val']:\r\n #new best model, reset stopping counter, store model\r\n train_state['early_stopping_step'] = 0\r\n train_state['early_stopping_best_val'] = val_loss\r\n best_model = copy.deepcopy(model)\r\n best_model.load_state_dict(model.state_dict())\r\n train_state['best_model'] = best_model\r\n else:\r\n #val loss not improved; increase early stopping counter\r\n train_state['early_stopping_step'] += 1\r\n if train_state['early_stopping_step'] >= self.early_stopping_criteria:\r\n train_state['stop_early'] = True\r\n print(\"Val loss failed to improve. Stopping early.\")\r\n break\r\n \r\n return train_state['best_model'],train_state","def train(self, x_data, y_data):\n self.model.fit(np.array(x_data), np.array(y_data),\n batch_size=2,\n epochs=3,\n verbose=1)\n self.model.save_weights(self.model_filename)","def train(self) -> None:\n\n # Check if in the saved model path there is already a trained model\n if self.config.TRN_HYPERP[\"save_path\"]:\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\"save_path\"]):\n print(\"INFO: An existing saved model will be used for inference\\n\")\n else:\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\n trainer = Trainer(**params)\n\n print(f\"INFO: Starting training ... \\n\")\n start_time = time.time()\n trainer.train()\n print(f\"\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\n\")\n\n # Instantiate the saved translator for inference\n saved_path = self.config.TRN_HYPERP[\"save_path\"]\n self.saved_translator = tf.saved_model.load(saved_path)\n else:\n print(\"INFO: Path to save model wasn't provided in config file. Can't train the model\\n\")","def train(self, training_data):\n pass","def train(self, tr_set_path: str, save_path: str, va_split: float=0.1, stratified_split: bool=False, early_stopping: bool=True):\n df_tr = read_csv_json(tr_set_path)\n if stratified_split:\n df_va = df_tr.groupby('intent').apply(lambda g: g.sample(frac=va_split, random_state=SEED))\n df_tr = df_tr[~df_tr.index.isin(df_va.index.get_level_values(1))]\n va_messages, va_labels = list(df_va.text), list(df_va.intent)\n va_dataset = [{'data': va_messages[i], 'label': va_labels[i]} for i in range(len(df_va))]\n tr_messages, tr_labels = list(df_tr.text), list(df_tr.intent)\n tr_dataset = [{'data': tr_messages[i], 'label': tr_labels[i]} for i in range(len(df_tr))]\n (x_train, y_train, le_encoder) = self.__preprocess(tr_dataset)\n (x_va, y_va, _) = self.__preprocess(va_dataset, le_encoder)\n else:\n tr_messages, tr_labels = list(df_tr.text), list(df_tr.intent)\n tr_dataset = [{'data': tr_messages[i], 'label': tr_labels[i]} for i in range(len(df_tr))]\n (x_train, y_train, le_encoder) = self.__preprocess(tr_dataset)\n\n K.clear_session()\n graph = tf.Graph()\n with graph.as_default():\n session = tf.Session()\n with session.as_default():\n session.run(tf.global_variables_initializer())\n model = self.__build_model(num_classes=len(le_encoder.categories_[0]))\n model.compile(\n loss=losses.CategoricalCrossentropy(label_smoothing=self.label_smoothing),\n #metrics=['categorical_accuracy'],\n optimizer=self.model_cfg.get('optimizer', 'adam') #default lr at 0.001\n #optimizer=optimizers.Adam(learning_rate=5e-4)\n )\n # early stopping callback using validation loss \n callback = tf.keras.callbacks.EarlyStopping(\n monitor=\"val_loss\",\n min_delta=0,\n patience=5,\n verbose=0,\n mode=\"auto\",\n baseline=None,\n restore_best_weights=True,\n )\n #callback = EarlyStoppingAtMaxMacroF1(\n # patience=100, # record all epochs\n # validation=(x_va, y_va)\n #)\n\n print('start training')\n history = model.fit(x_train, y_train,\n batch_size=self.model_cfg['batch_size'],\n epochs=100,\n validation_split=va_split if not stratified_split else 0,\n validation_data=(x_va, y_va) if stratified_split else None,\n callbacks=[callback] if early_stopping else None)\n history.history['train_data'] = tr_set_path\n print(f'finished training in {len(history.history[\"loss\"])} epochs')\n save(model, le_encoder, save_path, history)\n self.model = model\n self.session = session\n self.graph = graph\n self.le_encoder = le_encoder\n # return training history \n return history.history","def train_model(net, model_name, max_epochs=50, patience=7, batch_size=256, overwrite=False):\n file_exists = os.path.isfile(_get_model_file(CHECKPOINT_PATH, model_name))\n if file_exists and not overwrite:\n print(\"Model file already exists. Skipping training...\")\n else:\n if file_exists:\n print(\"Model file exists, but will be overwritten...\")\n\n # Defining optimizer, loss and data loader\n optimizer = optim.SGD(net.parameters(), lr=1e-2, momentum=0.9) # Default parameters, feel free to change\n loss_module = nn.CrossEntropyLoss()\n train_loader_local = data.DataLoader(\n train_set, batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True\n )\n\n val_scores = []\n best_val_epoch = -1\n for epoch in range(max_epochs):\n ############\n # Training #\n ############\n net.train()\n true_preds, count = 0.0, 0\n for imgs, labels in tqdm(train_loader_local, desc=f\"Epoch {epoch+1}\", leave=False):\n imgs, labels = imgs.to(device), labels.to(device) # To GPU\n optimizer.zero_grad() # Zero-grad can be placed anywhere before \"loss.backward()\"\n preds = net(imgs)\n loss = loss_module(preds, labels)\n loss.backward()\n optimizer.step()\n # Record statistics during training\n true_preds += (preds.argmax(dim=-1) == labels).sum()\n count += labels.shape[0]\n train_acc = true_preds / count\n\n ##############\n # Validation #\n ##############\n val_acc = test_model(net, val_loader)\n val_scores.append(val_acc)\n print(\n f\"[Epoch {epoch+1:2i}] Training accuracy: {train_acc*100.0:05.2f}%, Validation accuracy: {val_acc*100.0:05.2f}%\"\n )\n\n if len(val_scores) == 1 or val_acc > val_scores[best_val_epoch]:\n print(\"\\t (New best performance, saving model...)\")\n save_model(net, CHECKPOINT_PATH, model_name)\n best_val_epoch = epoch\n elif best_val_epoch <= epoch - patience:\n print(f\"Early stopping due to no improvement over the last {patience} epochs\")\n break\n\n # Plot a curve of the validation accuracy\n plt.plot([i for i in range(1, len(val_scores) + 1)], val_scores)\n plt.xlabel(\"Epochs\")\n plt.ylabel(\"Validation accuracy\")\n plt.title(f\"Validation performance of {model_name}\")\n plt.show()\n plt.close()\n\n load_model(CHECKPOINT_PATH, model_name, net=net)\n test_acc = test_model(net, test_loader)\n print((f\" Test accuracy: {test_acc*100.0:4.2f}% \").center(50, \"=\") + \"\\n\")\n return test_acc","def train(self):\n if self.retrain:\n self.states = self.get_states()\n self.transitions = self.get_transitions()\n self.matrix = self.get_matrix()\n self.save_training()\n else:\n self.load_training()","def train_model(self, initial=False):\n if len(self.loading.intersection({'model_train', 'base_model'})) > 0:\n return\n\n train_files = []\n if not self.model_trained and not initial:\n train_files = list(askopenfilenames())\n if len(train_files) is 0:\n return\n\n self.queue_gui_update('model_train_status', {'visible': False})\n self.queue_gui_update('btn_train_model', {'text': 'Training...'})\n self.queue_gui_update('model_train_loading', {'visible': True})\n self.loading.add('model_train')\n else:\n self.queue_gui_update('base_model_status', {'visible': False})\n self.queue_gui_update('btn_train_model', {'text': 'Loading base model...'})\n self.queue_gui_update('base_model_loading', {'visible': True})\n self.loading.add('base_model')\n\n\n self.model, is_base = get_model(train_files)\n if is_base or is_base is None:\n self.base_model_loaded = True\n self.model_trained = False\n self.queue_gui_update('base_model_status', {'value': u'\\u2713', 'text_color': 'green', 'visible': True})\n self.queue_gui_update('base_model_loading', {'visible': False})\n\n self.queue_gui_update('model_train_status', {'value': u'\\u2717', 'text_color': 'red', 'visible': True})\n self.queue_gui_update('btn_train_model', {'text': 'Train transfer model'})\n self.queue_gui_update('model_train_loading', {'visible': False})\n\n if is_base:\n self.loading.remove('base_model')\n else:\n self.model_trained = True\n self.queue_gui_update('model_train_status', {'value': u'\\u2713', 'text_color': 'green', 'visible': True})\n self.queue_gui_update('btn_train_model', {'text': 'Reset model'})\n self.queue_gui_update('model_train_loading', {'visible': False})\n self.loading.remove('model_train')\n\n self.model._make_predict_function()","def model_switch_to_training(self):\n pass","def train(self, model_type, params=None):\n Model = load_model_class(model_type)\n self.model_type = model_type\n X, y = self.task.make_dataset()\n self.final_data = X.copy()\n # Save preds\n preds = np.zeros_like(y.values).astype(np.float)\n with TMPFolder():\n N = len(X)\n n = N // self.cv\n # Assign a fold to each sample\n folds = np.random.permutation(np.repeat(np.arange(self.cv), n+1)[:N])\n if self.cv == 1:\n folds[:] = 1\n folds[np.random.permutation(np.arange(N))[:int(round(0.25 * N))]] = 0\n # Iterate over folds\n for k in range(self.cv):\n print(\"Fold\", k)\n # Create model\n model = Model()\n if params is not None:\n model.set_hp(params)\n # Create sub-dataset\n X_train = X[folds != k]\n y_train = y[folds != k]\n X_test = X[folds == k]\n y_test = y[folds == k]\n # Train the model\n model.train(X_train, y_train)\n # Make predictions on test samples\n y_pred = model.predict(X_test)\n # Save the predictions\n preds[folds == k] = y_pred\n self.model_save.append(model)\n # Save folds\n self.folds = folds\n self.is_trained = True\n self.preds = preds\n self.true_labels = y","def train(self):\n # Change directory to the code directory\n current_working_directory = os.getcwd()\n\n os.chdir(self.model_parameters[\"NN_code_directory\"])\n\n self.call_training_routine()\n\n # Come back to the original directory\n os.chdir(current_working_directory)","def train():\n # YOUR TRAINING CODE GOES HERE","def retrain(datapath, model_version):\n df = get_df(datapath)\n X = df.drop(columns='target')\n y = df['target']\n fitted_model = fit(RF, X, y)\n\n with open(f'trained_models/model_{model_version}.joblib', 'wb') as file:\n joblib.dump(fitted_model, file)","def train_val_training(X_train, y_train, model):\n # set pach where trained models will be saved to \n savepath = Path('/home/kwaygo/Documents/NUS/SPH6004/P2/SPH6004_P2/models/Regression')\n checkpoint_name = os.path.join(savepath, 'Weights-{epoch:03d}--{val_loss:.5f}.hdf5' ) \n # define callbacks\n cp = ModelCheckpoint(checkpoint_name, monitor='val_loss', verbose = 1, save_best_only = True, mode ='auto')\n es = EarlyStopping(monitor='val_loss', patience= 4, verbose=1)\n callbacks_list = [es, cp]\n # start training\n hist = model.fit(X_train, y_train, epochs=500, batch_size=500, validation_split = 0.2, callbacks=callbacks_list) \n \n print(\"[INFO] avg. ICU LOS of train set: {}, std ICU LOS of test set: {}\".format(np.mean(y_train), np.std(y_train)))\n # plot training History \n plotHist(hist)\n return model","def train_and_eval(self):\n self.__create_indexes()\n model = None\n model = None\n if self.model == 'OMult':\n model = OMult(self.kwargs)\n elif self.model == 'ConvO':\n model = ConvO(self.kwargs)\n elif self.model == 'QMult':\n model = QMult(self.kwargs)\n elif self.model == 'ConvQ':\n model = ConvQ(self.kwargs)\n elif self.model == 'OMultBatch':\n model = OMultBatch(self.kwargs)\n elif self.model == 'ConvOBatch':\n model = ConvOBatch(self.kwargs)\n elif self.model == 'QMultBatch':\n model = QMultBatch(self.kwargs)\n elif self.model == 'ConvQBatch':\n model = ConvQBatch(self.kwargs)\n else:\n print(self.model, ' is not valid name')\n raise ValueError\n\n self.train(model)\n self.eval(model)","def train(self, trainset, testset, niter=1000, ntest=300, epochs=int(1e6)):\n\n print('\\n>> Training begins!\\n')\n\n def fetch_dict(datagen, keep_prob=0.5):\n \"\"\"Format model input data.\"\"\"\n bx, by, br = next(datagen)\n while not (bx.shape[0] > 0 and bx.shape[1] > 0):\n bx, by, br = next(datagen)\n\n dec_lengths = np.full((bx.shape[0], ), bx.shape[1], dtype=np.int32)\n\n feed_dict = {\n self.xs_: bx,\n self.ys_: by,\n self.dec_inputs_length_: dec_lengths,\n self.ext_context_: br,\n self.keep_prob_: keep_prob\n }\n return feed_dict\n\n # setup session\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n\n load_classification_parameters(\n sess, \"models/model.ckpt-1500000\", \"class\")\n load_classification_parameters(\n sess, \"models/model.ckpt-1500000\", \"feat\")\n\n # get last checkpoint\n saver = tf.train.Saver(get_collections([\"encoder\", \"decoder\", \"proj\"]))\n ckpt = tf.train.get_checkpoint_state(self.ckpt_path)\n # verify it\n if ckpt and ckpt.model_checkpoint_path:\n try:\n saver.restore(sess, ckpt.model_checkpoint_path)\n except tf.OpError:\n # graph structure changed, cannot load, restart training\n pass\n\n try:\n # start training\n for j in range(epochs):\n mean_loss = 0\n for n_it in range(niter):\n _, loss = sess.run(\n [self.train_op, self.loss],\n feed_dict=fetch_dict(trainset))\n mean_loss += loss\n print(' [{}/{}]\\r'.format(n_it, niter))\n\n print('[{}] train loss : {}'.format(j, mean_loss / niter))\n saver.save(sess, self.ckpt_path + self.model_name + '.ckpt',\n global_step=j)\n\n # evaluate\n testloss = 0\n for _ in range(ntest):\n testloss += sess.run(\n [self.loss],\n feed_dict=fetch_dict(testset, keep_prob=1.))[0]\n print('test loss : {}'.format(testloss / ntest))\n\n except KeyboardInterrupt:\n print('\\n>> Interrupted by user at iteration {}'.format(j))","def train_model(self):\n self.best_epoch = {'auto':{}, 'coffee':{}, 'movie':{}, 'pizza':{}, 'restaurant':{}, 'uber':{} }\n self.best_f1 = {'auto':{}, 'coffee':{}, 'movie':{}, 'pizza':{}, 'restaurant':{}, 'uber':{} }\n for t in self.topic:\n if t != 'other':\n for st in self.topic2sub_topic[t].keys():\n\n print(\"Now training the classsfier for topic: \", t, \" ; intent: \", st)\n print(128 * \"=\")\n print(\"Input: str; Output: boolean(if the str contents the intent: \", st, \" ).\")\n print(64 * \"-\")\n X, y = self.get_data(t, st)\n print(\"data_loaded!\")\n X_train, X_dev, y_train, y_dev = self.my_train_test_split(X, y)\n best_f1 = 0\n for e in range(1,10):\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.InputLayer(input_shape=[1024, ]))\n model.add(tf.keras.layers.Dense(64, activation='relu'))\n model.add(tf.keras.layers.Dense(64, activation='relu'))\n model.add(tf.keras.layers.Dense(1, activation='relu'))\n model.compile(loss='mean_squared_logarithmic_error', optimizer='adam', metrics=[metrics.mae, metrics.categorical_accuracy])\n model.fit(X_train, y_train, epochs=e, batch_size=128)\n print(\"f1_score on dev set: \")\n f1 = self.f1_score_model(model, X_dev, y_dev)[0]\n if f1 > best_f1:\n self.model_zoo[t][st] = model\n model.save_weights(self.trained_w_folder+\"/%s/%s.h5\" %(t,st))\n self.best_epoch[t][st] = e\n self.best_f1[t][st] = f1\n best_f1 = f1\n\n print(64*\"=\")\n print()","def fit(self):\n \n # Open an existing model and get the training & test dataset and targets\n train_test_df, target_df = self._get_model_and_data(target=True, set_feature_def=True)\n \n # Check that the estimator is an supervised ML algorithm\n if self.model.estimator_type not in [\"classifier\", \"regressor\"]:\n err = \"Incorrect usage. The estimator specified is not a known classifier or regressor: {0}\".format(self.model.estimator)\n raise Exception(err)\n \n # Check which validation strategy is to be used, if any\n # For an explanation of cross validation in scikit-learn see: http://scikit-learn.org/stable/modules/cross_validation.html#multimetric-cross-validation\n if self.model.time_series_split > 0:\n self.model.validation = \"timeseries\"\n # Set up cross validation to be performed using TimeSeriesSplit\n self.model.cv = TimeSeriesSplit(n_splits=self.model.time_series_split, max_train_size=self.model.max_train_size)\n elif self.model.cv > 0:\n self.model.validation = \"k-fold\"\n elif self.model.test_size > 0:\n self.model.validation = \"hold-out\"\n else:\n self.model.validation = \"external\"\n\n if self.model.validation == \"hold-out\": \n # Split the data into training and testing subsets\n self.X_train, self.X_test, self.y_train, self.y_test = \\\n train_test_split(train_test_df, target_df, test_size=self.model.test_size, random_state=self.model.random_state)\n else:\n self.X_train = train_test_df\n self.y_train = target_df\n \n # Add the training and test data to the model if required\n if self.model.retain_data:\n self.model.X_train = self.X_train\n self.model.y_train = self.y_train\n \n try:\n self.model.X_test = self.X_test\n self.model.y_test = self.y_test\n except AttributeError:\n pass\n \n # Scale the targets and increase stationarity if required\n if self.model.scale_target or self.model.make_stationary:\n # Set up the target transformer\n self.model.target_transformer = TargetTransformer(scale=self.model.scale_target, make_stationary=self.model.make_stationary, stationarity_lags=self.model.stationarity_lags,\\\n missing=self.model.missing, scaler=self.model.scaler, logfile=self.logfile, **self.model.scaler_kwargs)\n\n # Fit the transformer to the training targets\n self.model.target_transformer = self.model.target_transformer.fit(self.y_train)\n\n # Apply the transformer to the training targets\n self.y_train = self.model.target_transformer.transform(self.y_train)\n # Drop samples where the target cannot be transformed due to insufficient lags\n self.X_train = self.X_train.iloc[len(self.X_train)-len(self.y_train):] \n \n # Add lag observations to the samples if required\n if self.model.lags or self.model.lag_target:\n # Check if the current sample will be included as an input, or whether we only use lag observations for predictions\n extrapolate = 1 if self.model.current_sample_as_input else 0\n # Add the lag observations\n self.X_train = self._add_lags(self.X_train, self.y_train, extrapolate=extrapolate, update_features_df=True)\n # Drop targets for samples which were dropped due to null values after adding lags.\n if len(self.y_train) > len(self.X_train):\n self.y_train = self.y_train.iloc[len(self.y_train)-len(self.X_train):]\n\n # If this is a Keras estimator, we require the preprocessing to return a data frame instead of a numpy array\n prep_return = 'df' if self.model.using_keras else 'np'\n\n # Construct the preprocessor\n prep = Preprocessor(self.model.features_df, return_type=prep_return, scale_hashed=self.model.scale_hashed, scale_vectors=self.model.scale_vectors,\\\n missing=self.model.missing, scaler=self.model.scaler, logfile=self.logfile, **self.model.scaler_kwargs)\n\n # Setup a list to store steps for the sklearn pipeline\n pipe_steps = [('preprocessor', prep)]\n\n if self.model.dim_reduction:\n # Construct the dimensionality reduction object\n reduction = self.decomposers[self.model.reduction](**self.model.dim_reduction_args)\n \n # Include dimensionality reduction in the pipeline steps\n pipe_steps.append(('reduction', reduction))\n self.model.estimation_step = 2\n else:\n self.model.estimation_step = 1 \n\n # If this is a Keras estimator, update the input shape and reshape the data if required\n if self.model.using_keras:\n # Update the input shape based on the final number of features after preprocessing\n self._keras_update_shape(prep)\n\n # Add the Keras build function, architecture and prediction_periods to the estimator keyword arguments\n self.model.estimator_kwargs['build_fn'] = self._keras_build_fn\n self.model.estimator_kwargs['architecture'] = self.model.architecture\n self.model.estimator_kwargs['prediction_periods'] = self.model.prediction_periods\n\n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(10)\n \n # Check than an identifier has been provided for sorting data if this is a sequence prediction problem\n if self.model.lags or len(self.model.first_layer_kwargs[\"input_shape\"]) > 1:\n assert len(self.model.original_features_df[self.model.original_features_df['variable_type'].isin([\"identifier\"])]) == 1, \\\n \"An identifier is mandatory when using lags or with sequence prediction problems. Define this field in your feature definitions.\"\n\n # Cater for multi-step predictions\n if self.model.prediction_periods > 1:\n # Transform y to a vector of values equal to prediction_periods\n self.y_train = utils.vectorize_array(self.y_train, steps=self.model.prediction_periods)\n # Drop values from x for which we don't have sufficient y values\n self.X_train = self.X_train.iloc[:-len(self.X_train)+len(self.y_train)]\n\n # Add a pipeline step to update the input shape and reshape the data if required\n # This transform will also add lag observations if specified through the lags parameter\n # If lag_target is True, an additional feature will be created for each sample using the previous value of y \n reshape = Reshaper(first_layer_kwargs=self.model.first_layer_kwargs, logfile=self.logfile)\n pipe_steps.append(('reshape', reshape))\n self.model.estimation_step += self.model.estimation_step\n\n # Avoid tensorflow error for keras models\n # https://github.com/tensorflow/tensorflow/issues/14356\n # https://stackoverflow.com/questions/40785224/tensorflow-cannot-interpret-feed-dict-key-as-tensor\n kerasbackend.clear_session()\n \n # Try assuming the pipeline involves a grid search\n try:\n # Construct an estimator\n estimator = self.algorithms[self.model.estimator](**self.model.estimator_kwargs)\n\n # Prepare the grid search using the previously set parameter grid\n grid_search = GridSearchCV(estimator=estimator, param_grid=self.model.param_grid, **self.model.grid_search_args)\n \n # Add grid search to the pipeline steps\n pipe_steps.append(('grid_search', grid_search))\n\n # Construct the sklearn pipeline using the list of steps\n self.model.pipe = Pipeline(pipe_steps)\n\n if self.model.validation in [\"k-fold\", \"timeseries\"]:\n # Perform K-fold cross validation\n self._cross_validate()\n\n # Fit the training data to the pipeline\n if self.model.using_keras:\n # https://stackoverflow.com/questions/54652536/keras-tensorflow-backend-error-tensor-input-10-specified-in-either-feed-de\n session = tf.Session()\n kerasbackend.set_session(session)\n with session.as_default():\n with session.graph.as_default():\n sys.stdout.write(\"\\nMODEL: {}, INPUT SHAPE: {}\\n\\n\".format(self.model.name, self.model.first_layer_kwargs['input_shape']))\n y = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\n self.model.pipe.fit(self.X_train, y)\n else:\n self.model.pipe.fit(self.X_train, self.y_train.values.ravel())\n\n # Get the best parameters and the cross validation results\n grid_search = self.model.pipe.named_steps['grid_search']\n self.model.best_params = grid_search.best_params_\n self.model.cv_results = grid_search.cv_results_\n\n # Get the best estimator to add to the final pipeline\n estimator = grid_search.best_estimator_\n\n # Update the pipeline with the best estimator\n self.model.pipe.steps[self.model.estimation_step] = ('estimator', estimator)\n\n except AttributeError:\n # Construct an estimator\n estimator = self.algorithms[self.model.estimator](**self.model.estimator_kwargs)\n\n # Add the estimator to the pipeline steps\n pipe_steps.append(('estimator', estimator))\n\n # Construct the sklearn pipeline using the list of steps\n self.model.pipe = Pipeline(pipe_steps)\n\n if self.model.validation in [\"k-fold\", \"timeseries\"]:\n # Perform K-fold cross validation\n self._cross_validate()\n\n # Fit the training data to the pipeline\n if self.model.using_keras:\n # https://stackoverflow.com/questions/54652536/keras-tensorflow-backend-error-tensor-input-10-specified-in-either-feed-de\n session = tf.Session()\n kerasbackend.set_session(session)\n with session.as_default():\n with session.graph.as_default():\n sys.stdout.write(\"\\nMODEL: {}, INPUT SHAPE: {}\\n\\n\".format(self.model.name, self.model.first_layer_kwargs['input_shape']))\n y = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\n self.model.pipe.fit(self.X_train, y)\n else:\n self.model.pipe.fit(self.X_train, self.y_train.values.ravel())\n \n if self.model.validation == \"hold-out\": \n # Evaluate the model using the test data \n self.calculate_metrics(caller=\"internal\")\n \n if self.model.calc_feature_importances:\n # Select the dataset for calculating importances\n if self.model.validation == \"hold-out\":\n X = self.X_test\n y = self.y_test # Already a numpy array after calculate_metrics\n else:\n X = self.X_train\n y = self.y_train.values.ravel()\n \n # Calculate model agnostic feature importances\n self._calc_importances(X = X, y = y)\n\n # Persist the model to disk\n self.model = self.model.save(self.model.name, self.path, overwrite=self.model.overwrite, compress=self.model.compress)\n \n # Update the cache to keep this model in memory\n self._update_cache()\n \n # Prepare the output\n if self.model.validation != \"external\": \n message = [[self.model.name, 'Model successfully trained, tested and saved to disk.',\\\n time.strftime('%X %x %Z', time.localtime(self.model.state_timestamp)),\\\n \"{0} model has a score of {1:.3f} against the test data.\"\\\n .format(self.model.estimator, self.model.score), self.model.score]]\n else:\n message = [[self.model.name, 'Model successfully trained and saved to disk.',\\\n time.strftime('%X %x %Z', time.localtime(self.model.state_timestamp)),\\\n \"{0} model score unknown as test_size was <= 0.\"\\\n .format(self.model.estimator), np.NaN]]\n \n self.response = pd.DataFrame(message, columns=['model_name', 'result', 'time_stamp', 'score_result', 'score'])\n \n # Send the reponse table description to Qlik\n self._send_table_description(\"fit\")\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n # Finally send the response\n return self.response","def fit(self,\n X_train,\n y_train, \n X_test, \n y_test):\n \n #instantiate path_model_dirs dictionary so we can know where the models are saved\n self.path_model_dirs = {}\n\n for key in self.models_dict.keys():\n \n if self.verbose >=1: print('\\n----',key,'----')\n\n #define model directory\n path_model_dir = _os.path.join(self.path_GridSearchCV_dir, key)\n self.path_model_dirs[key] = path_model_dir\n if self.verbose >=1: print('path_model_dir:',path_model_dir)\n \n model_type = type(self.models_dict[key]['model'])\n if 'sklearn' in str(model_type) or 'xgboost' in str(model_type):\n path_file = _os.path.join(path_model_dir,'model_dict.dill')\n elif 'Net' in key:\n path_file = _os.path.join(path_model_dir,'best_params_.dill')\n\n if self.retrain or _os.path.isfile(path_file)==False:\n self.models_dict[key] = self._single_model_GridSearchCV(self.models_dict[key], \n X_train, y_train, \n X_test, y_test,\n path_model_dir)\n\n else: #reload previously trained model\n if 'sklearn' in str(type(self.models_dict[key]['model'])):\n self.models_dict[key] = self.load('model_dict', 'dill', path_model_dir)\n elif 'Net' in key:\n #check kwargs for epochs\n epochs = 100\n for item in self.kwargs.items():\n if 'epochs' in item[0]: epochs = item[1]\n self.models_dict[key] = self.load_NeuralNet(path_model_dir, \n X_train, y_train, \n epochs)\n\n y_pred = self.models_dict[key]['best_model'].predict(X_test)\n\n if 'Net' not in key:\n self.models_dict[key]['best_pred_score'] = self.models_dict[key]['best_model'].score(X_test, y_test)\n else:\n self.models_dict[key]['best_pred_score'] = self.models_dict[key]['best_model'].evaluate(X_test, y_test, verbose =0)\n \n if self.verbose >=1:\n print('\\tbest_cv_score:',self.models_dict[key]['best_cv_score'])\n print('\\tbest_pred_score:',self.models_dict[key]['best_pred_score'])\n\n for metric_key in self.metrics.keys():\n if self.metrics[metric_key] !=None:\n try:\n self.models_dict[key][metric_key] = self.metrics[metric_key](y_test, y_pred)\n print('\\t',metric_key,':',self.models_dict[key][metric_key])\n except Exception as e:\n print('Exception occured for',metric_key,':',str(e))\n\n if 'sklearn' in str(type(self.models_dict[key]['model'])):\n self.save(self.models_dict[key], 'model_dict', 'dill', path_model_dir)\n elif 'Net' in key:\n model_dict_subset = self.models_dict[key].copy()\n for key in self.models_dict[key].keys():\n if key not in ['y_test','y_pred','best_pred_score'] +list(self.metrics.keys()):\n model_dict_subset.pop(key)","def train(self, train_dataset):\n\n # check fine_tuning option\n model_path = os.path.join(self.check_point, 'model.pt')\n if self.fine_tune and not os.path.exists(model_path):\n raise Exception('Cannot find %s.' %model_path)\n elif self.fine_tune and os.path.exists(model_path):\n if self.verbose:\n pass\n self.model = torch.load(model_path)\n self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)\n \n # capture best model\n best_val_psnr = -1\n best_model_state = self.model.state_dict()\n\n # Train the model\n for epoch in range(self.num_epochs):\n self._epoch_step(train_dataset, epoch)\n self.scheduler.step()\n\n\n\n # capture running PSNR on train and val dataset\n train_psnr, train_ssim, _, _ = self._check_PSNR(train_dataset)\n self.hist_train_psnr.append(train_psnr)\n \n\n \n # write the model to hard-disk for testing\n if not os.path.exists(self.check_point):\n os.makedirs(self.check_point)\n model_path = os.path.join(self.check_point, 'model.pt')\n torch.save(self.model, model_path)","def train(sess, env, Xdata, ydata, X_valid=None, y_valid=None, epochs=1,\n load=False, shuffle=True, batch_size=128, name='model'):\n if load:\n if not hasattr(env, 'saver'):\n return print('\\nError: cannot find saver op')\n print('\\nLoading saved model')\n return env.saver.restore(sess, 'model/{}'.format(name))\n\n print('\\nTrain model')\n n_sample = Xdata.shape[0]\n n_batch = int((n_sample+batch_size-1) / batch_size)\n for epoch in range(epochs):\n print('\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\n\n if shuffle:\n print('\\nShuffling data')\n ind = np.arange(n_sample)\n np.random.shuffle(ind)\n Xdata = Xdata[ind]\n ydata = ydata[ind]\n\n for batch in range(n_batch):\n print(' batch {0}/{1}'.format(batch + 1, n_batch), end='\\r')\n begin = batch * batch_size\n ending = min(n_sample, begin + batch_size)\n sess.run(env.train_op, feed_dict={env.x: Xdata[begin:ending],\n env.y: ydata[begin:ending],\n env.training: True})\n if X_valid is not None:\n evaluate(sess, env, X_valid, y_valid)\n\n if hasattr(env, 'saver'):#在此处保存模型吧？\n print('\\n Saving model')\n os.makedirs('model', exist_ok=True)\n env.saver.save(sess, 'model/{}'.format(name))","def train_model(model, x_train, y_train, x_test, y_test,\n epochs=None, batch_size=None):\n\n # Training\n if batch_size is None:\n batch_size = 128\n if epochs is None:\n epochs = 20\n\n print('x_train shape:', x_train.shape)\n print('x_test shape:', x_test.shape)\n\n print('Train...')\n model.fit(x_train,\n y_train,\n batch_size=batch_size,\n epochs=epochs,\n validation_data=(x_test, y_test),\n use_multiprocessing=True)","def save_model(self, epoch):\n # Set the name for the model\n gen_lungs_filename = 'gen_lungs_model_epoch_{}.h5'.format(epoch + 1)\n disc_lungs_filename = 'disc_lungs_model_epoch_{}.h5'.format(epoch + 1)\n train_summary_lungs_filename = 'train_summary_lungs_epoch_{}.csv'.format(epoch + 1)\n\n gen_organs_filename = 'gen_organs_model_epoch_{}.h5'.format(epoch + 1)\n disc_organs_filename = 'disc_organs_model_epoch_{}.h5'.format(epoch + 1)\n train_summary_organs_filename = 'train_summary_organs_epoch_{}.csv'.format(epoch + 1)\n\n # Save the model and train summary\n self.generator_lungs.save(op.join(self.model_dir, gen_lungs_filename), include_optimizer=True)\n self.disc_lungs.save(op.join(self.model_dir, disc_lungs_filename), include_optimizer=True)\n self.summary_writer_lungs.to_csv(op.join(self.train_summary_dir, train_summary_lungs_filename))\n\n self.generator_organs.save(op.join(self.model_dir, gen_organs_filename), include_optimizer=True)\n self.disc_organs.save(op.join(self.model_dir, disc_organs_filename), include_optimizer=True)\n self.summary_writer_organs.to_csv(op.join(self.train_summary_dir, train_summary_organs_filename))\n return self","def train(cleaner, data_source, save_to=\"../models/model.pkl\"):\n df = pd.read_csv(data_source)\n df = df[pd.notnull(df['tags'])]\n print(\"Start : Pre-cleaning process . . . \")\n print(\" HTML decoding . . . done\")\n print(\" lowercase text . . . done\")\n print(\" replace [/(){}\\[\\]\\|@,;] symbols by space . . . done\")\n print(\" remove remaining symbols . . . done\")\n print(\" remove stopwords . . . done\")\n df['post'] = df['post'].apply(cleaner)\n print(\"End : Pre-cleaning process\")\n x = df.post\n y = df.tags\n # no need for split data in final training stage\n # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 42)\n print(\"Start : model creation process . . . \")\n sgd = Pipeline([('vect', CountVectorizer()),\n ('tfidf', TfidfTransformer()),\n ('clf', SGDClassifier(loss='hinge', penalty='l2', alpha=1e-3, random_state=42, max_iter=5,\n tol=None)),\n ])\n # sgd.fit(X_train, y_train)\n sgd.fit(x, y)\n print(\"End : model creation process\")\n model = open(save_to, 'wb')\n pickle.dump(sgd, model)\n model.close()\n print(\"Trained model saved to \" + save_to)\n return sgd","def train(self, train_set, model, num_epochs=5, resume=False, optimizer=None, dev_set=None):\n\n\t\ttorch.cuda.empty_cache()\n\t\tself.resume = resume\n\t\tif resume:\n\t\t\tlatest_checkpoint_path = Checkpoint.get_latest_epoch_checkpoint(self.load_dir)\n\t\t\tprint('resuming {} ...'.format(latest_checkpoint_path))\n\t\t\tresume_checkpoint = Checkpoint.load(latest_checkpoint_path)\n\t\t\tmodel = resume_checkpoint.model\n\t\t\tself.optimizer = resume_checkpoint.optimizer\n\n\t\t\t# check var\n\t\t\tmodel.set_var('attention_forcing', self.attention_forcing)\n\t\t\tmodel.set_var('debug_count', 0)\n\t\t\tmodel.reset_use_gpu(self.use_gpu)\n\t\t\tprint('attention forcing: {}'.format(model.attention_forcing))\n\t\t\tprint('use gpu: {}'.format(model.use_gpu))\n\t\t\tif self.use_gpu:\n\t\t\t\tmodel = model.cuda()\n\t\t\telse:\n\t\t\t\tmodel = model.cpu()\n\n\t\t\t# A walk around to set optimizing parameters properly\n\t\t\tresume_optim = self.optimizer.optimizer\n\t\t\tdefaults = resume_optim.param_groups[0]\n\t\t\tdefaults.pop('params', None)\n\t\t\tdefaults.pop('initial_lr', None)\n\t\t\tself.optimizer.optimizer = resume_optim.__class__(model.parameters(), **defaults)\n\n\t\t\tstart_epoch = resume_checkpoint.epoch\n\t\t\tstep = resume_checkpoint.step\n\n\t\telse:\n\t\t\tstart_epoch = 1\n\t\t\tstep = 0\n\n\t\t\tfor name, param in model.named_parameters():\n\t\t\t\tlog = self.logger.info('{}:{}'.format(name, param.size()))\n\t\t\t\t# check embedder init\n\t\t\t\t# if 'embedder' in name:\n\t\t\t\t# \tprint('{}:{}'.format(name, param[5]))\n\n\t\t\tif optimizer is None:\n\t\t\t\toptimizer = Optimizer(torch.optim.Adam(model.parameters(), \n\t\t\t\t\t\t\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\n\n\t\t\t\t# set scheduler\n\t\t\t\t# optimizer.set_scheduler(torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer.optimizer, 'min'))\n\n\t\t\tself.optimizer = optimizer\n\n\t\tself.logger.info(\"Optimizer: %s, Scheduler: %s\" % (self.optimizer.optimizer, self.optimizer.scheduler))\n\n\t\tself._train_epoches(train_set, model, num_epochs, start_epoch, step, dev_set=dev_set)\n\t\t\n\t\treturn model","def train_model(clf, dataloaders, criterion, optimizer, num_epochs=25,\n patience=10, save_model_path=None, resume=False, finetune=False):\n\n since = time.time()\n\n val_acc_history = []\n\n #best_model_wts = copy.deepcopy(clf.state_dict())\n best_acc = 0.0\n best_epoch = 0\n epoch = 0\n\n if resume:\n assert save_model_path is not None\n if save_model_path in glob(save_model_path):\n _model, _criterion, _optimizer, _epoch, _loss, _accuracy, _history = _resume_from_checkpoint(save_model_path)\n #if finetune:\n # model.set_requires_grad(_model, True)\n clf = _model\n criterion = _criterion\n optimizer = _optimizer\n epoch = _epoch + 1\n best_epoch = _epoch\n best_acc = _accuracy\n val_acc_history = _history\n else:\n raise Exception(\"No such model file in the specified path.\")\n\n if finetune:\n model.set_requires_grad(clf, True)\n\n best_model_wts = copy.deepcopy(clf.state_dict())\n test_dataloader = dataloaders.pop('test', None)\n\n clf = clf.to(device)\n\n for epoch in range(epoch, num_epochs):\n print('Epoch {}/{}'.format(epoch + 1, num_epochs))\n print('-' * 10)\n\n # Each epoch has a training and validation phase\n for phase in ['train', 'val']:\n if phase == 'train':\n clf.train() # Set model to training mode\n else:\n clf.eval() # Set model to evaluate mode\n\n running_loss = 0.0\n running_corrects = 0\n\n # Iterate over data.\n for inputs, labels in tqdm(dataloaders[phase]):\n inputs = inputs.to(device)\n labels = labels.to(device).long()\n\n # zero the parameter gradients\n optimizer.zero_grad()\n\n # forward\n # track history if only in train\n with torch.set_grad_enabled(phase == 'train'):\n # Get model outputs and calculate loss\n outputs = clf(inputs)\n loss = criterion(outputs, labels)\n\n _, preds = torch.max(outputs, 1)\n\n # backward + optimize only if in training phase\n if phase == 'train':\n loss.backward()\n optimizer.step()\n\n # statistics\n running_loss += loss.item() * inputs.size(0)\n running_corrects += torch.sum(preds == labels.data)\n\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\n epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)\n\n print('{} Loss: {:.4f}, Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n\n # deep copy the model\n if phase == 'val':\n val_acc_history.append(epoch_acc)\n if phase == 'val' and epoch_acc > best_acc:\n best_acc = epoch_acc\n best_model_wts = copy.deepcopy(clf.state_dict())\n best_epoch = epoch\n if save_model_path:\n _save_checkpoint(clf, criterion, optimizer, epoch, epoch_loss, best_acc, val_acc_history, save_model_path)\n print(\"Model checkpoint saved successfully in the given path!\")\n print()\n if patience is not None:\n if epoch - best_epoch >= patience:\n break\n\n time_elapsed = time.time() - since\n print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n print('Best val Acc: {:4f}'.format(best_acc))\n\n # load best model weights\n clf.load_state_dict(best_model_wts)\n\n test_acc = test_model(clf, test_dataloader, criterion, optimizer)\n if not save_model_path:\n if IN_COLAB:\n save_model_path = \"/content/drive/My Drive/Audio-classification-using-multiple-attention-mechanism/best_weights.h5\"\n else:\n save_model_path = \"best_weights.h5\"\n save_model(clf, os.path.splitext(save_model_path)[0] + (\"_final_finetuned\" if finetune else \"_final\") + os.path.splitext(save_model_path)[1])\n\n return clf, val_acc_history, test_acc","def train_model():\n return model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels), shuffle='True')","def train_on_whole_data(self):\n save_model_path = './savedModel/cnn-model'\n self.build_graph(save_model_path)\n\n tf.reset_default_graph()\n with tf.Session(graph=tf.get_default_graph()) as sess:\n try:\n graph = self.__load_graph(sess, save_model_path)\n self.__train_and_report(sess, graph, range(1, 6), save_model_path)\n except Exception as e:\n logger.error(\"Something is missing from the previous saved graph, remove it and regenerate graph\")\n shutil.rmtree(\"./savedModel\")\n exit()","def train_model(dataset):\n\n # clear the session so that we can train more than one model\n K.clear_session()\n\n # initialize the model\n model = initalizer.init_nn()\n\n # fit the model\n model.fit(dataset, epochs=40)\n\n return model","def train(self, trainfile):","def save_model(self, path):\n try:\n # os.makedirs(osp.dirname(path), exist_ok=1)\n joblib.dump(self.model, path)\n except Exception as e:\n print(e)\n print(\"Couldn't save scikit learn model on path {}!\".format(path))","def train():\n pass","def train(data_dir, epochs, batch_size, lr, optimizer, categories):\n run = Run.get_context()\n\n run.log('optimizer', optimizer)\n run.log('minibatch_size', batch_size)\n run.log('learning_rate', lr)\n run.log('categories', categories)\n\n # Get model and data objects\n train_generator, validation_generator = create_dataset_generators(\n data_dir, batch_size, categories\n )\n \n model = create_model(lr=lr, classes=train_generator.num_classes, optimizer_name=optimizer)\n print(model.optimizer)\n \n os.makedirs(\"./outputs\", exist_ok=True)\n\n with open('./outputs/labels.json', 'w') as fo:\n json.dump(train_generator.class_indices, fo)\n\n aml_callback = AzureMLCallback(run)\n checkpointer = ModelCheckpoint(\n filepath=\"./outputs/weights_{epoch:02d}.hdf5\", period=25)\n\n history = model.fit_generator(\n train_generator,\n steps_per_epoch=train_generator.samples / batch_size,\n epochs=epochs,\n validation_data=validation_generator,\n validation_steps=validation_generator.samples / batch_size,\n verbose=2,\n callbacks=[aml_callback, checkpointer],\n )\n\n model.save(\"./outputs/final_model.hdf5\")","def train_test_model_batch():\n train=learning.Train_kmer_clf()\n train.run()","def trainModel(model, train_raw, validation_raw):\n # compile and train the model using the generator function\n train_generator = generator(train_raw, batch_size=32)\n validation_generator = generator(validation_raw, batch_size=32)\n\n # model checkpoint\n now = datetime.datetime.now()\n datenow = now.strftime(\"%Y-%m-%d-\")\n #file_path_model = \"Model_checkpoints/\" + datenow + \"model-weights-{epoch:02d}-{val_loss:0.2f}.hdf5\"\n file_path_model = \"Model_checkpoints/\" + datenow + \"model-weights.hdf5\"\n checkpoint = ModelCheckpoint(file_path_model, monitor='val_loss', verbose=1, save_best_only=True, mode='auto')\n callbacks_list = [checkpoint]\n model.compile(loss='mse', optimizer='adam')\n # left/center/right images, and all flipped\n ntrain = len(train_raw)*3*2\n nvalid = len(validation_raw)*3*2\n history_object = model.fit_generator(train_generator, samples_per_epoch= \\\n ntrain, validation_data=validation_generator, \\\n nb_val_samples=nvalid, nb_epoch=10, \\\n callbacks = callbacks_list, verbose=1)\n #history_object = model.fit_generator(train_generator, steps_per_epoch= ntrain, \\\n # validation_data=validation_generator, validation_steps=nvalid, \\\n # callbacks = callbacks_list, epochs=5, verbose = 1) \n return history_object","def save_model(model):\n model.to_disk(\"../model/custom_ner_model\")","def train_teacher (nb_teachers, teacher_id):\n # Load the dataset\n X_train, X_test, y_train, y_test = models.get_dataset()\n\n print(X_train.shape)\n print(y_train.shape)\n print(X_test.shape)\n print(y_test.shape)\n \n # Retrieve subset of data for this teacher\n data, labels = partition.partition_dataset(X_train,\n y_train,\n nb_teachers,\n teacher_id)\n\n print(\"Length of training data: \" + str(len(labels)))\n\n # Define teacher checkpoint filename and full path\n\n filename = str(nb_teachers) + '_teachers_' + str(teacher_id) + '.hdf5'\n filename2 = str(nb_teachers) + '_teachers_' + str(teacher_id) + '.h5'\n \n # Perform teacher training need to modify \n \n\n # Create teacher model\n model, opt = models.create_two_layer_mlp(46) # num of cols\n model.compile(loss='binary_crossentropy',\n optimizer=\"Adam\",\n metrics=['accuracy'])\n model, hist = models.training(model, data, X_test, labels, y_test,filename)\n\n #modify\n model_json = model.to_json()\n with open(\"model.json\", \"w\") as json_file:\n json_file.write(model_json)\n# serialize weights to HDF5\n model.save_weights(filename2)\n print(\"Saved model to disk\")\n return True","def train(self, X_train, y_train):\n\n self.model_pipeline.fit(X_train, y_train)","def train_model():\n if (not request.json \n or not 'data-format' in request.json\n or not 'ML-model' in request.json\n or not 'source-data-directory' in request.json\n or not 'source-data-repo' in request.json):\n abort(400)\n\n data_format = request.json['data-format']\n ML_model = request.json['ML-model']\n source_data_directory = request.json['source-data-directory']\n source_data_repo = request.json['source-data-repo']\n \n start = time.time()\n\n do_train(model_name=ML_model, \n repo_url=source_data_repo, \n repo_data_directory=source_data_directory, \n data_format=data_format)\n \n end = time.time()\n\n runningtime = (end - start)\n\n return f'Model {ML_model} trained using source data in directory {source_data_directory}, running time {runningtime} seconds', 201","def setup_training(model, train_loader, valid_loader, hps):\r\n\r\n train_dir = os.path.join(hps.save_root, \"train\")\r\n if not os.path.exists(train_dir): os.makedirs(train_dir)\r\n\r\n if hps.restore_model != 'None':\r\n logger.info(\"[INFO] Restoring %s for training...\", hps.restore_model)\r\n bestmodel_file = os.path.join(train_dir, hps.restore_model)\r\n loader = ModelLoader()\r\n loader.load_pytorch(model, bestmodel_file)\r\n else:\r\n logger.info(\"[INFO] Create new model for training...\")\r\n\r\n run_training(model, train_loader, valid_loader, hps) # this is an infinite loop until interrupted\r","def train_model(model, X_train, X_valid, Y_train, Y_valid):\n\n # Let's CreateCheckPoint so as to save our best models and model Logs after every epoch.\n # This checkPoint function will be called as callback functions after every epoch.\n\n checkpoint = ModelCheckpoint(\n 'model-{epoch:03d}.h5', monitor='val_loss', verbose=0, save_best_only=True, mode='auto')\n\n tensorboard = TensorBoard(log_dir=\"log\\{}\".format(time())) \n\n model.compile(loss='mean_squared_error', optimizer=Adam(lr=LEARNING_RATE))\n\n model.fit_generator(batch_generator(DATA_DIR, X_train, Y_train, BATCH_SIZE, True),\n SAMPLES_PER_EPOCH,\n NO_OF_EPOCHS,\n max_q_size=1,\n validation_data=batch_generator(\n DATA_DIR, X_valid, Y_valid, BATCH_SIZE, False),\n nb_val_samples=len(X_valid),\n callbacks=[checkpoint, tensorboard],\n verbose=1\n )","def save_model(self):\n self.pred_net.save((self.save_path / \"iqn_pred_net\").absolute().as_posix())\n self.target_net.save((self.save_path / \"iqn_target_net\").absolute().as_posix())","def train_model(model, dataset, validation_set, epochs, label_name,\n batch_size=None):\n\n # Split the training set into features and label.\n features = {name:np.array(value) for name, value in dataset.items()}\n label = np.array(features.pop(label_name))\n \n # Split the validation set into features and label.\n val_features = {name:np.array(value) for name, value in validation_set.items()}\n val_label = np.array(val_features.pop(label_name))\n \n history = model.fit(x=features, y=label, batch_size=batch_size,\n epochs=epochs, shuffle=True, validation_data=(val_features, val_label)) \n\n # The list of epochs is stored separately from the rest of history.\n epochs = history.epoch\n \n # To track the progression of training, gather a snapshot\n # of the model's mean squared error at each epoch. \n hist = pd.DataFrame(history.history)\n rmse = hist[\"root_mean_squared_error\"]\n\n return epochs, rmse, hist","def start_training(self):\n i = 0\n for _ in range(self.train_steps):\n print(f\"Start Training Step {i + 1}\")\n self.model.learn(total_timesteps=self.total_time_steps)\n self.model.save(self.save_path)\n print(f\"Finished Training Step {i + 1}\")\n i += 1","def train_and_eval(model_dir, model_type, train_steps, train_data, test_data, train_embeddings_file_name, test_embeddings_file_name, positive_labels, combination_method, method):\n \n index_map, weights = wvd.load(train_embeddings_file_name)\n #Get positive labels\n positive_labels = positive_labels.split(',')\n \n print(\"reading data...\")\n train_file_name = train_data \n df_train = pd.read_table(train_file_name, dtype={'node1':str, 'node2':str})\n df_train = df_train.sample(frac=1)\n\n # remove NaN elements\n df_train = df_train.dropna(how='any', axis=0)\n \n df_train[LABEL_COLUMN] = (\n df_train[\"label\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\n\n model_dir = tempfile.mkdtemp() if not model_dir else model_dir\n print(\"model directory = %s\" % model_dir)\n \n train_x, _, train_y, _ = get_input(df_train, weights, index_map, combination_method)\n \n print(\"\\nBuilding model...\")\n m = build_estimator(model_dir, model_type, weights, index_map, combination_method)\n \n print(\"\\nTraining model...\")\n if model_type == \"regressor\":\n m.fit(train_x, train_y, n_epoch=train_steps, show_metric=True, snapshot_epoch=False)\n \n print(\"\\nTesting model...\")\n index_map, weights = wvd.load(test_embeddings_file_name)\n \n print(\"reading data...\")\n test_file_name = test_data\n df_test = pd.read_table(test_file_name, dtype={'node1':str, 'node2':str})\n df_test = df_test.sample(frac=1)\n\n # remove NaN elements\n df_test = df_test.dropna(how='any', axis=0)\n \n df_test[LABEL_COLUMN] = (\n df_test[\"label\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\n \n if model_type == \"regressor\":\n test_x, test_original_y, test_index_y, test_original_x = get_input(df_test, weights, index_map, combination_method, data_purpose='test')\n node_sets = get_node_sets(test_original_x, test_original_y)\n \n print(\"\\nPredicting:\")\n model_predictions = m.predict(test_x)\n model_predictions = list(model_predictions)\n #Covert back to 1 and 0\n predictions = []\n model_predictions_probs = []\n for prediction in model_predictions:\n predictions.append(prediction[1]) #non-thresholded value of positve class\n model_predictions_probs.append(prediction[1])\n \n k = int(len([i for i in test_original_y if i == 1]) * 0.3)\n do_evaluations([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \n positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method)\n #Uncomment to log ranked links\n #log_predictions([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \n # positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method,\n # outfilename=combination_method, method=method)","def train(self, dataset, k=20, n_epochs=10, save_dir='./models', save=True, model_name='GRU4REC'):\n print(f'Training {model_name}...')\n\n for epoch in range(n_epochs):\n results = self.run_epoch(dataset, k=k, training=True)\n results = [f'{k}:{v:.3f}' for k, v in results.items()]\n print(f'epoch:{epoch+1:2d}/{\"/\".join(results)}')\n \n # Store the intermediate model\n if save:\n save_dir = Path(save_dir)\n if not save_dir.exists(): save_dir.mkdir()\n model_fname = f'{model_name}_{self.loss_type}_{self.optimizer_type}_{self.lr}_epoch{epoch+1:d}'\n torch.save(self.gru.state_dict(), save_dir/model_fname)"],"string":"[\n \"def trainAndSaveModels():\\n print \\\"\\\\nTraining models...\\\"\\n\\n #Use the best-performed train and test splitted data \\n X_train = pickle.load(open('X_train.sav','rb'))\\n X_test = pickle.load(open('X_test.sav','rb'))\\n Y_train = pickle.load(open('Y_train.sav','rb'))\\n \\n #train models\\n lassoModel = LassoPrediction(X_train, X_test, Y_train)\\n forestModel = RandomForestPrediction(X_train, X_test, Y_train)\\n boostingModel = GradientBoosting(X_train, X_test, Y_train)\\n \\n #save the modes\\n pickle.dump(lassoModel,open('lasso_Model.sav','wb'))\\n pickle.dump(forestModel,open('forest_Model.sav','wb'))\\n pickle.dump(boostingModel,open('sgb_Model.sav','wb'))\",\n \"def fit(self, train_set, train_labels, validation_set=None, validation_labels=None, restore_previous_model=False):\\n\\n with tf.Session() as self.tf_session:\\n self._initialize_tf_utilities_and_ops(restore_previous_model)\\n self._train_model(train_set, train_labels, validation_set, validation_labels)\\n self.tf_saver.save(self.tf_session, self.models_dir + self.model_name)\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def train(\\n model_path=\\\"./trained_model/\\\",\\n model_file_name=\\\"model.h5\\\",\\n training_data_path=\\\"./train.csv\\\",\\n):\\n config = SConfig(training_data_path=training_data_path)\\n s2s = Seq2Seq(config)\\n s2s.fit()\\n s2s.save_model(path_to_model=model_path, model_file_name=model_file_name)\",\n \"def fit_store(X, y):\\n print(\\\"Fitting model to training set...\\\")\\n model = pr.build_model.fit_model(X, y)\\n pickle.dump(model, open(\\\"models/\\\" + \\\"model\\\" + \\\".pkl\\\", \\\"wb\\\"))\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.opt.num_epochs):\\n self.run_epoch()\\n if (self.epoch + 1) % self.opt.save_frequency == 0:\\n self.save_model()\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def train(self):\\n # setup model\\n self.createModel()\\n self.setGenerators()\\n self.buildCallbacks()\\n self.printParameters()\\n \\n # train model\\n _ = self.model.fit_generator(\\n generator = self.trainGen,\\n validation_data = self.validateGen,\\n steps_per_epoch = self.steps_per_epoch,\\n validation_steps = self.validation_steps,\\n epochs = self.epochs,\\n use_multiprocessing = True,\\n callbacks = self.callbacks)\\n # clear save paths to avoid overwriting accidentaly\\n self.saveName = None\",\n \"def train_model(self):\\n if not self.is_exist(self.path_model_directory):\\n # Then create the parent folder\\n os.makedirs(self.path_model_directory)\\n\\n # Create a meta-data pickle for the model\\n self.create_meta_data_pickle()\\n\\n # Necessary meta-data file must be created before starting the training. Check if the file exists\\n if self.is_exist(self.path_model_metadata):\\n\\n # We do not need to train a model if there is already a best model for the same training exist\\n try:\\n self.model = load_model(self.path_best_model)\\n return\\n except:\\n self.log_event('There is no best trained model found in the parent folder. Going with the training...')\\n\\n # Load the model meta-data\\n self.load_model_metadata()\\n self.encoding_vector_size = self.number_of_distinct_items\\n\\n # Iterate trough the split data for the training\\n for split_number in range(self.k_split):\\n split_path = f'split_{str(split_number)}/'\\n split_directory = self.path_model_directory + split_path\\n\\n # Check the split directory is already created. If it is, then we can directly start the training by using the existing data\\n if self.is_exist(split_directory):\\n try:\\n self.load_best_tuned_model(split_number)\\n except (IndexError, FileNotFoundError):\\n self.load_fold_k_data_and_fit(split_number=int(split_number))\\n\\n else:\\n # Create a folder for the split data and prepare the data for the training\\n os.makedirs(split_directory)\\n\\n # Create an array which will contain train features-labels and test features-labels\\n train_array = np.full(4, fill_value=self.mask_value, dtype=object)\\n train_index = 0\\n for position, split_name in enumerate(['train_split_', 'test_split_']):\\n training_features_directory = split_directory + f'{split_name}{str(split_number)}_all_training_features.data'\\n training_targets_directory = split_directory + f'{split_name}{str(split_number)}_all_training_targets.data'\\n fold_directory = self.path_shared_folds + f'{split_name}{str(split_number)}.fold'\\n\\n self.process_training_data(fold_directory=fold_directory)\\n\\n self.save_data_to_disk(data_to_save=self.all_features, path_to_save=training_features_directory)\\n train_array[train_index] = self.all_features\\n train_index += 1\\n self.all_features = None # Memory Management\\n\\n self.save_data_to_disk(data_to_save=self.all_targets, path_to_save=training_targets_directory)\\n train_array[train_index] = self.all_targets\\n train_index += 1\\n self.all_targets = None # Memory Management\\n\\n # Assign the input data to respective variables for the training\\n self.train_features = train_array[0]\\n self.train_targets = train_array[1]\\n self.test_features = train_array[2]\\n self.test_targets = train_array[3]\\n del train_array\\n\\n self.start_hyper_parameter_tuning(split_number)\\n\\n self.retrieve_best_model(metric=self.hyper_parameters['metric'])\",\n \"def set_train(self):\\n self.model.train()\",\n \"def train(self):\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: train method invoked!\\\")\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: training {self.model.__class__.__name__} model!\\\")\\n\\n self.model.fit(self.trainX, self.trainY)\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def train_model(x_data, y_data, model_type):\\n # def lr model object\\n clr = None\\n try:\\n clr = model_list[model_type]()\\n except Exception as e:\\n print(e)\\n # fit model\\n clr.fit(x_data, y_data)\\n # save model in pkl file\\n try:\\n joblib.dump(clr, \\\"model/\\\" + model_type + \\\".pkl\\\")\\n except Exception as e:\\n print(e)\\n return clr\",\n \"def train_full_model(X,y_train):\\n scaler = MinMaxScaler()\\n x_train = scaler.fit_transform(X)\\n\\n #chose model\\n # model = RandomForestClassifier()\\n model = GradientBoostingClassifier()\\n\\n\\n #train\\n print(\\\"train model\\\")\\n tic = time.time()\\n model.fit(x_train,y_train)\\n tac = time.time()\\n print(\\\"elapsed time\\\", tac-tic)\\n\\n #save data\\n save_data(model,scaler,x_train,y_train)\",\n \"def train_model_4(model, X_train, y_train, image_name):\\n # Train the model\\n model.fit(X_train, y_train)\\n \\n # Save the model\\n model_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_model.joblib\\\".format(image_name))\\n joblib.dump(model, model_file)\\n \\n return model, model\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.num_epochs):\\n print(\\\"EPOHA\\\")\\n self.run_epoch()\\n print(\\\"SAVE MODEL\\\")\\n self.save_model()\",\n \"def model_train(data_dir,test=False):\\r\\n \\r\\n if not os.path.isdir(MODEL_DIR):\\r\\n os.mkdir(MODEL_DIR)\\r\\n\\r\\n if test:\\r\\n print(\\\"... test flag on\\\")\\r\\n print(\\\"...... subsetting data\\\")\\r\\n print(\\\"...... subsetting countries\\\")\\r\\n \\r\\n ## fetch time-series formatted data\\r\\n ts_data = fetch_ts(data_dir)\\r\\n\\r\\n ## train a different model for each data sets\\r\\n for country,df in ts_data.items():\\r\\n if test and country not in ['all','united_kingdom']:\\r\\n continue\\r\\n model_name = re.sub(\\\"\\\\.\\\",\\\"_\\\",str(MODEL_VERSION))\\r\\n saved_model = os.path.join(MODEL_DIR,\\r\\n \\\"sl-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_test_model = os.path.join(MODEL_DIR,\\r\\n \\\"test-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_baseline = os.path.join(BASELINE_DIR,\\r\\n \\\"b-sl-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_test_baseline = os.path.join(BASELINE_DIR,\\r\\n \\\"b-test-{}-{}.joblib\\\".format(country,model_name))\\r\\n if (test and (not os.path.isfile(saved_test_model))) or ((not test) and (not os.path.isfile(saved_model))):\\r\\n _model_train(df,country,test=test)\\r\\n if (test and (not os.path.isfile(saved_test_baseline))) or ((not test) and (not os.path.isfile(saved_baseline))):\\r\\n _baseline_train(df,country,test=test)\",\n \"def train_model(self):\\n self.logger.info('Loading the data...')\\n train_data = self.load_data(split=\\\"train\\\")\\n dev_data = self.load_data(split=\\\"dev\\\")\\n self.config.best_model = os.path.join(self.config.output_dir,\\\"best_model\\\")\\n self.logger.info('Training the model, outputdir=%s...,best_model=%s' % (self.config.output_dir,self.config.best_model))\\n\\n train_params = {\\n \\\"overwrite_output_dir\\\" : True,\\n \\\"reprocess_input_data\\\": True,\\n \\\"learning_rate\\\" : self.config.learning_rate,\\n \\\"num_train_epochs\\\" : self.config.num_train_epochs,\\n \\\"train_batch_size\\\" : self.config.train_batch_size,\\n \\\"eval_batch_size\\\" : self.config.eval_batch_size,\\n \\\"gradient_accumulation_steps\\\": self.config.gradient_accumulation_steps,\\n \\\"use_early_stopping\\\" : self.config.early_stopping,\\n \\\"fp16\\\" : False,\\n \\\"classification_report\\\" : True,\\n \\\"evaluate_during_training\\\" : True,\\n \\\"evaluate_during_training_verbose\\\" : True,\\n \\\"best_model_dir\\\": self.config.best_model,\\n \\\"save_model_every_epoch\\\" : self.config.save_model_every_epoch,\\n \\\"save_steps\\\" : self.config.save_steps,\\n \\\"save_optimizer_and_scheduler\\\" : self.config.save_optimizer_and_scheduler,\\n \\\"save_best_model\\\": True,\\n }\\n\\n ## train the model \\n self.model.train_model(\\n train_data,\\n eval_data=dev_data,\\n output_dir=self.config.output_dir,\\n show_running_loss=False,\\n args=train_params,\\n )\\n\\n ## backing up the config and create pointer to best model \\n with open(os.path.join(self.config.best_model,\\\"trainer_config.json\\\"),'w') as mconfig:\\n mconfig.write(json.dumps(self.config.__dict__))\\n self.config.existing_model = self.config.best_model\",\n \"def train():\\n import training\\n\\n # Ensure output directories exist\\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\\n os.makedirs(cfg.model_path, exist_ok=True)\\n os.makedirs(cfg.log_path, exist_ok=True)\\n\\n # Load (standardized) input data and target values\\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\\n val_x, val_y, _ = _load_data(cfg.validation_set)\\n\\n # Try to create reproducible results\\n np.random.seed(cfg.initial_seed)\\n\\n # Save free parameters to disk\\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\\n 'parameters.json'))\\n\\n training.train(tr_x, tr_y, val_x, val_y)\",\n \"def train(self, train_set=dt.treat_data(dt.load_data(\\\"data/train.csv\\\"))):\\n if self.model is None:\\n return\\n my_callback = keras.callbacks.callbacks.EarlyStopping(monitor='loss', min_delta=0.0, patience=1000, verbose=2,\\n mode='auto', baseline=None, restore_best_weights=False)\\n\\n train_data, train_labels = train_set\\n history = self.model.fit(x=train_data, y=train_labels, epochs=100000, batch_size=45,\\n callbacks=[my_callback], verbose=2, shuffle=True)\\n self.model.save(\\\"titanic_\\\" + str(time.time()) + \\\".h5\\\")\\n return history\",\n \"def set_model_for_train(self):\\n if self.train_time is None:\\n self.train_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\\n\\n self.curr_folder = data_functions.create_path(\\n self.save_path, self.train_time)\\n logger.info(f\\\"training results will be stored in: {self.curr_folder}\\\")\\n\\n self.save_model_params()\\n self.train_generator, self.val_generator = \\\\\\n self.clarifruit_train_val_generators()\\n keras_logs_path = self.set_model_checkpint()\\n\\n return keras_logs_path\",\n \"def set_train(self):\\n for m in self.models.values():\\n m.train()\",\n \"def train_model(self, *args, **kwargs):\\n self.model.train(self.training, *args, **kwargs)\",\n \"def train_and_save(self, checkpoint_dir):\\n dataset = self._read_dataset(self._train_dataset_path)\\n features, labels = self.get_features_and_labels(dataset)\\n self._model.partial_fit(features, labels, classes=self._classes)\\n checkpoint_path = self._save_model(checkpoint_dir)\\n return checkpoint_path\",\n \"def training(self):\\n self.model.fit(self.train_x, self.train_y)\",\n \"def run(self) -> None:\\n self.model = self.trainer.train_model(self.model, self.data)\",\n \"def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \\n model_file=None, save_path=None):\\n \\n print(\\\"- Loading configuration...\\\")\\n if model_name in models_default_params:\\n default_params = models_default_params[model_name]\\n else:\\n print(\\\"Error: the model '{}' has not been implemented\\\".format(model_name))\\n return\\n custom_objects = default_params['custom_objects']\\n patch_size = default_params['patch_size']\\n if save_path is None:\\n save_path = default_params['default_path']\\n if os.path.isfile(save_path):\\n print(\\\"Warning: {} is an existing file and will be overwritten.\\\".format(save_path))\\n print(\\\"- Configuration loaded.\\\")\\n \\n print(\\\"- Loading datasets...\\\")\\n train_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Training/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Training/Labels/\\\",\\n patch_size = patch_size)\\n val_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Validation/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Validation/Labels/\\\",\\n patch_size = patch_size)\\n print(\\\"- Data loaded.\\\")\\n \\n print(\\\"- Initialising model...\\\")\\n if(model_file is not None): # Further train existing model\\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\\n else: # Create new model\\n if model_name == 'fcn':\\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \\n use_pretraining=False, freeze_base=False)\\n elif model_name == 'pspnet':\\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\\n input_shape=patch_size)\\n elif model_name == 'mobilenetv2':\\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \\n\\n model.compile(\\n optimizer = optimizers.Adam(lr = 0.00001),\\n loss = losses.categorical_crossentropy,\\n metrics = [metrics.categorical_accuracy]) \\n model.summary() \\n print(\\\"- Model initialised.\\\")\\n \\n tensorboard = callbacks.TensorBoard(log_dir='./logs')\\n csv_logger = callbacks.CSVLogger('logs/training.csv')\\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\\n save_weights_only=True,\\n save_best_only=True)\\n \\n print(\\\"- Starting training.\\\")\\n model.fit_generator(\\n generator=train_gen,\\n steps_per_epoch=steps_per_epoch,\\n epochs=epochs,\\n validation_data=val_gen,\\n validation_steps=validation_steps,\\n # callbacks=[checkpoint, csv_logger]\\n )\\n print(\\\"- Training complete.\\\")\\n \\n model.save(save_path)\\n print(\\\"- Model saved to {}\\\".format(save_path))\",\n \"def train_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def train(self):\\n self.emission_model(self.train_data)\\n self.transition_model(self.train_data)\",\n \"def train(self, dataset, model_dir):\\n raise NotImplementedError\",\n \"def save_trained_model(self):\\n save_keras_sequential(self.model, self.RELATIVE_DATA_DIRECTORY, self.get_name())\\n logger.info(f\\\"DQL Trader: Saved trained model\\\")\",\n \"def train(\\n self,\\n training_set,\\n validation_set=None,\\n test_set=None,\\n save_path=\\\"model\\\",\\n return_state_dict: bool = False,\\n **kwargs,\\n ):\\n # ====== General setup =======\\n output_features = self.model.output_features\\n\\n # Only use signals when on the main thread to avoid issues with CherryPy\\n # https://github.com/ludwig-ai/ludwig/issues/286\\n if threading.current_thread() == threading.main_thread():\\n # set the original sigint signal handler\\n # as we want to restore it at the end of training\\n self.original_sigint_handler = signal.getsignal(signal.SIGINT)\\n signal.signal(signal.SIGINT, self.set_steps_to_1_or_quit)\\n\\n metrics_names = get_metric_names(output_features)\\n\\n # ====== Setup file names =======\\n model_hyperparameters_path = None\\n tensorboard_log_dir = None\\n if self.is_coordinator():\\n os.makedirs(save_path, exist_ok=True)\\n model_hyperparameters_path = os.path.join(save_path, MODEL_HYPERPARAMETERS_FILE_NAME)\\n tensorboard_log_dir = os.path.join(save_path, \\\"logs\\\")\\n\\n # Sync save_path across the workers\\n save_path = self.distributed.broadcast_object(save_path or \\\"\\\")\\n\\n training_progress_tracker_path = None\\n training_checkpoints_path = None\\n if save_path:\\n training_progress_tracker_path = os.path.join(save_path, TRAINING_PROGRESS_TRACKER_FILE_NAME)\\n training_checkpoints_path = os.path.join(save_path, TRAINING_CHECKPOINTS_DIR_PATH)\\n\\n self.callback(\\n lambda c: c.on_trainer_train_setup(self, save_path, self.is_coordinator()), coordinator_only=False\\n )\\n\\n # ====== Setup session =======\\n checkpoint_manager = None\\n checkpoint = self.distributed.create_checkpoint_handle(\\n dist_model=self.dist_model, model=self.model, optimizer=self.optimizer, scheduler=self.scheduler\\n )\\n checkpoint_manager = CheckpointManager(checkpoint, training_checkpoints_path, device=self.device)\\n\\n # ====== Setup Tensorboard writers =======\\n train_summary_writer = None\\n validation_summary_writer = None\\n test_summary_writer = None\\n if self.is_coordinator() and not self.skip_save_log and tensorboard_log_dir:\\n train_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, TRAINING))\\n if validation_set is not None and validation_set.size > 0:\\n validation_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, VALIDATION))\\n if test_set is not None and test_set.size > 0:\\n test_summary_writer = SummaryWriter(os.path.join(tensorboard_log_dir, TEST))\\n\\n # ================ Resume logic ================\\n self.callback(lambda c: c.on_resume_training(self.is_coordinator()))\\n\\n should_resume = self.resume and self.resume_files_exist(\\n training_progress_tracker_path, training_checkpoints_path\\n )\\n # make sure all workers are on the same page about resuming.\\n should_resume = self.distributed.broadcast_object(should_resume, name=\\\"should_resume\\\")\\n\\n if should_resume:\\n try:\\n progress_tracker = self.resume_training_progress_tracker(training_progress_tracker_path)\\n self.resume_weights_and_optimizer(training_checkpoints_path, checkpoint)\\n logger.info(\\\"Resuming training from previous run.\\\")\\n except Exception:\\n # This may happen if model training is interrupted after the progress tracker is initialized\\n # but before any real training progress is made.\\n progress_tracker = get_new_progress_tracker(\\n batch_size=self.batch_size,\\n learning_rate=self.base_learning_rate,\\n best_eval_metric_value=get_initial_validation_value(self.validation_metric),\\n best_increase_batch_size_eval_metric=get_initial_validation_value(\\n self.increase_batch_size_eval_metric\\n ),\\n output_features=output_features,\\n )\\n logger.info(\\\"Failed to resume training from previous run. Creating fresh model training run.\\\")\\n else:\\n progress_tracker = get_new_progress_tracker(\\n batch_size=self.batch_size,\\n learning_rate=self.base_learning_rate,\\n best_eval_metric_value=get_initial_validation_value(self.validation_metric),\\n best_increase_batch_size_eval_metric=get_initial_validation_value(self.increase_batch_size_eval_metric),\\n output_features=output_features,\\n )\\n logger.info(\\\"Creating fresh model training run.\\\")\\n\\n # Distributed: broadcast initial variable states from rank 0 to all other processes.\\n # This is necessary to ensure consistent initialization of all workers when\\n # training is started with random weights or restored from a checkpoint.\\n self.distributed.sync_model(self.dist_model)\\n self.distributed.sync_optimizer(self.optimizer)\\n self.scheduler.load_state_dict(self.distributed.broadcast_object(self.scheduler.state_dict()))\\n\\n # For DeepSpeed, we need to set the batch size here in case it was modfied during auto-tuning\\n self.distributed.set_batch_size(self.dist_model, self.batch_size)\\n\\n set_random_seed(self.random_seed)\\n\\n try:\\n with training_set.initialize_batcher(\\n batch_size=self.batch_size,\\n should_shuffle=self.should_shuffle,\\n random_seed=self.random_seed,\\n distributed=self.distributed,\\n ignore_last=True,\\n augmentation_pipeline=self.model.get_augmentation_pipelines(),\\n ) as batcher:\\n # ================ Training Loop ================\\n self.total_steps = get_total_steps(self.epochs, batcher.steps_per_epoch, self.train_steps)\\n\\n # Get the terminal steps per checkpoint.\\n final_steps_per_checkpoint = get_final_steps_per_checkpoint(\\n batcher.steps_per_epoch,\\n self.steps_per_checkpoint,\\n self.checkpoints_per_epoch,\\n self.is_coordinator(),\\n )\\n final_steps_per_checkpoint = min(final_steps_per_checkpoint, self.total_steps)\\n early_stopping_steps = final_steps_per_checkpoint * self.early_stop\\n\\n # Initialize the learning rate scheduler.\\n self.scheduler = LRScheduler(\\n self.config.learning_rate_scheduler,\\n self.optimizer,\\n steps_per_checkpoint=final_steps_per_checkpoint,\\n total_steps=self.total_steps,\\n )\\n\\n if self.is_coordinator():\\n logger.info(\\n f\\\"Training for {self.total_steps} step(s), approximately \\\"\\n f\\\"{int(self.total_steps / batcher.steps_per_epoch)} epoch(s).\\\"\\n )\\n if self.early_stop < 0:\\n logger.info(\\\"Early stopping policy: None\\\")\\n else:\\n logger.info(\\n f\\\"Early stopping policy: {self.early_stop} round(s) of evaluation, or \\\"\\n f\\\"{early_stopping_steps} step(s), approximately \\\"\\n f\\\"{int(early_stopping_steps / batcher.steps_per_epoch)} epoch(s).\\\\n\\\"\\n )\\n logger.info(f\\\"Starting with step {progress_tracker.steps}, epoch: {progress_tracker.epoch}\\\")\\n\\n progress_bar_config = {\\n \\\"desc\\\": \\\"Training\\\",\\n \\\"total\\\": self.total_steps,\\n \\\"disable\\\": is_progressbar_disabled(),\\n \\\"file\\\": sys.stdout,\\n }\\n progress_bar = LudwigProgressBar(self.report_tqdm_to_ray, progress_bar_config, self.is_coordinator())\\n\\n while progress_tracker.steps < self.total_steps:\\n # note that batch size may change over epochs\\n batcher.set_epoch(progress_tracker.epoch, progress_tracker.batch_size)\\n\\n # epoch init\\n start_time = time.time()\\n\\n # Reset the metrics at the start of the next epoch\\n self.dist_model.train() # Sets model to training mode.\\n self.model.reset_metrics()\\n\\n self.callback(lambda c: c.on_epoch_start(self, progress_tracker, save_path))\\n\\n # Trains over a full epoch of data.\\n should_break = self._train_loop(\\n batcher,\\n progress_tracker,\\n save_path,\\n train_summary_writer,\\n progress_bar,\\n training_set,\\n validation_set,\\n test_set,\\n start_time,\\n validation_summary_writer,\\n test_summary_writer,\\n model_hyperparameters_path,\\n output_features,\\n metrics_names,\\n checkpoint_manager,\\n final_steps_per_checkpoint,\\n early_stopping_steps,\\n )\\n\\n # ================ Post Training Epoch ================\\n progress_tracker.epoch += 1\\n self.callback(lambda c: c.on_epoch_end(self, progress_tracker, save_path))\\n\\n if self.is_coordinator():\\n # ========== Save training progress ==========\\n logger.debug(\\n f\\\"Epoch {progress_tracker.epoch} took: \\\"\\n f\\\"{time_utils.strdelta((time.time() - start_time) * 1000.0)}.\\\"\\n )\\n if not self.skip_save_progress:\\n checkpoint_manager.save(progress_tracker.steps)\\n if self.is_coordinator():\\n progress_tracker.save(os.path.join(save_path, TRAINING_PROGRESS_TRACKER_FILE_NAME))\\n\\n if not self.skip_save_model and self.skip_all_evaluation:\\n # All evaluation was skipped, so save the current step as the best so far.\\n checkpoint_manager.save_best(progress_tracker.steps)\\n\\n # Early stop if needed.\\n if should_break:\\n break\\n finally:\\n # ================ Finished Training ================\\n self.callback(\\n lambda c: c.on_trainer_train_teardown(self, progress_tracker, save_path, self.is_coordinator()),\\n coordinator_only=False,\\n )\\n\\n if train_summary_writer is not None:\\n train_summary_writer.close()\\n if validation_summary_writer is not None:\\n validation_summary_writer.close()\\n if test_summary_writer is not None:\\n test_summary_writer.close()\\n\\n if not self.skip_save_model and self.skip_all_evaluation:\\n # All evaluation was skipped, so save the current step as the best so far.\\n checkpoint_manager.save_best(progress_tracker.steps)\\n\\n if not self.skip_save_progress:\\n checkpoint_manager.close()\\n\\n # Load the best weights from saved checkpoint\\n state_dict = None\\n if self.distributed.is_coordinator():\\n if not self.skip_save_model:\\n state_dict = checkpoint_manager.get_best_checkpoint_state_for_inference(self.return_device)\\n if not return_state_dict:\\n if self.distributed.is_model_parallel():\\n # Assume the full weights cannot fit in memory on GPU\\n self.model = self.model.cpu()\\n _, unexpected_keys = self.model.load_state_dict(state_dict, strict=False)\\n assert unexpected_keys == [], f\\\"Unexpected keys found in state dict: {unexpected_keys}\\\"\\n elif return_state_dict:\\n state_dict = self.model.cpu().state_dict()\\n\\n # When running with Ray, we only need to return the state dict, as it's faster and cheaper to send the\\n # state dict over the network than to load the model state here, serialize it back to a state dict, then\\n # load it back on the head node.\\n return_value = self.model if not return_state_dict else state_dict\\n\\n # restore original sigint signal handler\\n if self.original_sigint_handler and threading.current_thread() == threading.main_thread():\\n signal.signal(signal.SIGINT, self.original_sigint_handler)\\n\\n return (\\n return_value,\\n progress_tracker.train_metrics,\\n progress_tracker.validation_metrics,\\n progress_tracker.test_metrics,\\n )\",\n \"def train(self, X_train, y_train):\\n self.model.fit(X_train, y_train)\",\n \"def train(fitted_model_filename):\\n click.echo(\\\"Mode: training.\\\\n\\\")\\n defaults = get_defaults()\\n\\n fitted_model_filename = add_extension(fitted_model_filename)\\n\\n # derive final path for fitted model as base output path for fitted models + model filename\\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n\\n new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n boot_data = bootstrap(new_options, mode=\\\"train\\\")\\n defaults = boot_data['defaults']\\n\\n X_train, y_train = boot_data['data']\\n fitted_model = train_model(X_train, y_train, defaults)\\n\\n # dump fitted model\\n os.makedirs(defaults.OUTPUT.FITTED_MODELS_PATH, exist_ok=True)\\n save_obj(fitted_model, defaults.OUTPUT.FITTED_MODEL_PATH)\",\n \"def train(self, x_data, y_data):\\n for model in self.list_of_models:\\n model.fit(x_data, y_data)\\n self.trained_models.append(model)\",\n \"def fit_model(\\n model,\\n trainset,\\n valset,\\n sensor,\\n target_var,\\n output_models_path,\\n early_stop_patience,\\n epochs,\\n time_stmp_str,\\n out_model_name,\\n history_out_name,\\n):\\n train_X = trainset[\\\"X\\\"]\\n train_y = trainset[\\\"y\\\"]\\n\\n val_X = valset[\\\"X\\\"]\\n val_y = valset[\\\"y\\\"]\\n\\n # fit network\\n # que corte despues de no mejorar mucho\\n early_stopping = EarlyStopping(\\n monitor=\\\"val_loss\\\",\\n patience=early_stop_patience,\\n verbose=1,\\n mode=\\\"min\\\",\\n restore_best_weights=True,\\n )\\n # que use el mejor modelo\\n checkpoint = ModelCheckpoint(\\n out_model_name, save_best_only=True, monitor=\\\"val_loss\\\", mode=\\\"min\\\", verbose=2\\n )\\n\\n history = model.fit(\\n train_X,\\n train_y,\\n epochs=epochs,\\n validation_data=(val_X, val_y),\\n verbose=1,\\n shuffle=False,\\n callbacks=[checkpoint, early_stopping],\\n )\\n\\n with open(history_out_name, \\\"wb\\\") as file_pi:\\n pickle.dump(history, file_pi)\\n\\n return load_model(out_model_name)\",\n \"def train_network(self):\\n if self.trainData:\\n if self.verbose:\\n print('Started training...')\\n\\n for epoch in range(135):\\n pass\\n # save the model\\n else:\\n if self.verbose:\\n print('No train data available')\",\n \"def train(self, training_set):\\n\\n lengths = [ seq.shape[0] for seq in training_set ]\\n\\n #preprocessing the training set to obtain the desired shape\\n concatenated_set = self.preprocessing( training_set )\\n\\n #fitting the model\\n self.model.fit(concatenated_set, lengths)\\n\\n return\",\n \"def _set_train(self):\\n\\n if not self.model.__dict__['training']:\\n self.model.train()\",\n \"def train(self, x, t):\\n for i in range(self.number_model):\\n curr_model = self.all_model[i]\\n curr_model.fit(x, t)\",\n \"def train(self, training_set):\\n self.originModel.train(training_set)\\n return self\",\n \"def trainAndPredict(self):\\r\\n print(\\\"train\\\")\\r\\n filename= 'finalized_model.sav'\\r\\n # train the algorithm on training data and predict using the testing data\\r\\n model = self.svc_model.fit(self.X.T, self.Y)\\r\\n pickle.dump(model, open(filename, 'wb'))\\r\\n #model = pickle.load(open(filename, 'rb'))\\r\\n pred1 =model.predict(self.TestSet.T)\\r\\n # print the accuracy score of the model\\r\\n print(\\\"LinearSVC accuracy : \\\", accuracy_score(self.TestSetY, pred1, normalize=True))\",\n \"def train_model(self):\\r\\n alpha, accuracy_rate = self.select_model()\\r\\n # Initialize logistic regression with alpha(learning rate)\\r\\n lg = logisticregression(C=alpha)\\r\\n # Train the model.\\r\\n lg.fit(self.training_data, self.target_data)\\r\\n # Save the trained model as .pkl file.\\r\\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\\r\\n print \\\"Estimated Parameters of Logistic Regression\\\"\\r\\n # Estimated parameters of logistic regression.\\r\\n print lg.get_params()\",\n \"def train(\\n train_sets: tuple,\\n test_sets: tuple,\\n input_shape: tuple = (1, 128, 128, 1),\\n model_version=\\\"1.0.0\\\",\\n epochs: int = 100,\\n classes: int = 2,\\n batch_size: int = 1,\\n verbose=1,\\n out_dir: str = \\\"saved_models\\\"):\\n (x_train, y_train), (x_test, y_test) = train_sets, test_sets\\n y_train = keras.utils.to_categorical(y_train, classes)\\n y_test = keras.utils.to_categorical(y_test, classes)\\n m = get_model(model_version)\\n if not m:\\n return\\n model = m.build_model(input_shape)\\n model.compile(\\n loss=BinaryCrossentropy(),\\n optimizer=RMSprop(learning_rate=0.0001),\\n metrics=['accuracy']\\n )\\n saver = ModelSaver(out_dir)\\n csv_logger = CSVLogger(\\n \\\"%s/%s/log.csv\\\" %\\n (out_dir, datetime.datetime.now().date().strftime(\\\"%Y_%m_%d\\\")),\\n append=True,\\n separator=','\\n )\\n history = model.fit(\\n x_train,\\n y_train,\\n batch_size=batch_size,\\n epochs=epochs,\\n verbose=verbose,\\n validation_data=(x_test, y_test),\\n callbacks=[saver, csv_logger]\\n )\\n model.save(\\\"%s/%s/final.hd5\\\" %\\n (out_dir, datetime.datetime.now().date().strftime(\\\"%Y_%m_%d\\\")))\\n print(\\\"Model saved in %s as final.hd5\\\" % out_dir)\\n plot_results(\\n history,\\n epochs,\\n out_dir\\n )\",\n \"def train_model_3(model, X_train, y_train, X_val, y_val, image_name):\\n # Train the model\\n model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=100)\\n \\n # Save the model\\n model_file = os.path.join(OUTPUT_DIR, \\\"{}_model.txt\\\".format(image_name))\\n model.booster_.save_model(model_file)\\n \\n return model, model\",\n \"def train():\\n \\n ## check for request data\\n if not request.json:\\n print(\\\"ERROR: API (train): did not receive request data\\\")\\n return jsonify(False)\\n\\n ## set the test flag\\n test = False\\n if 'mode' in request.json and request.json['mode'] == 'test':\\n test = True\\n\\n print(\\\"... training model\\\")\\n model = model_train(test=test)\\n print(\\\"... training complete\\\")\\n\\n return(jsonify(True))\",\n \"def train(train_x_df, train_y_df):\\n x = list(train_x_df.columns.values)\\n model = build_model(len(x))\\n\\n os.makedirs(\\\"./saved_models\\\", exist_ok=True)\\n\\n cp_callback = keras.callbacks.ModelCheckpoint(\\n checkpoint_path, save_weights_only=True, save_best_only=True, verbose=1\\n )\\n\\n # first 80 percent for training\\n train_x = train_x_df[1:246005]\\n train_y = train_y_df[1:246005]\\n\\n # other 20 percent for evaluating\\n eval_x = train_x_df[246006 : len(train_x_df) - 1]\\n eval_y = train_y_df[246006 : len(train_y_df) - 1]\\n\\n # train model\\n model.fit(\\n train_x,\\n train_y,\\n epochs=epochs,\\n validation_split=0.2,\\n verbose=0,\\n batch_size=batch_size,\\n callbacks=[cp_callback],\\n )\\n\\n print(\\\"done training\\\")\\n\\n # export the tensorflow model to a onnx model file\\n # for loading in tfe and secure enclave\\n export_to_onnx(\\n x,\\n model,\\n \\\"./house_credit_default.onnx\\\",\\n )\\n\\n # evaluate the model using AUC, the metric used in the kaggle competition\\n loss = model.evaluate(eval_x, eval_y, batch_size=batch_size)\\n\\n predictions = model.predict(eval_x, batch_size=batch_size)\\n auc = tf.metrics.auc(eval_y, predictions)\\n\\n print(\\\"Evaluation Loss:\\\", loss[0])\\n print(\\\"Accuracy:\\\", loss[1])\\n print(\\\"AUC: \\\", auc[0][1])\",\n \"def train(model_conf:ModelConf, train_set, validation_set=None):\\n model_conf.print_conf()\\n\\n images_placeholder = tf.placeholder(dtype=tf.float32, shape=[None, model_conf.HEIGHT*model_conf.WIDTH])\\n labels_placeholder = tf.placeholder(dtype=tf.int64, shape=[None])\\n model = DenseNet(model_conf, is_training=True, images=images_placeholder, labels=labels_placeholder)\\n model.build_graph()\\n\\n summary_op = tf.summary.merge_all()\\n saver = tf.train.Saver(tf.all_variables())\\n\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n summary_writer = tf.summary.FileWriter(model_conf.SUMMARY_DIR, graph=sess.graph)\\n\\n for step in range(model_conf.NUM_STEPS):\\n train_images, train_labels = train_set.next_batch()\\n feed_dict = {images_placeholder: train_images,\\n labels_placeholder: train_labels\\n }\\n start_time = time.time()\\n [loss_value, acc_value, _, lr_value] = sess.run([model.loss, model.acc, model.train_op, model.learning_rate],\\n feed_dict=feed_dict)\\n duration = time.time() - start_time\\n if step % 10 == 0:\\n _print_log('training', step, loss_value, acc_value, lr_value, duration)\\n\\n if step % 100 == 0:\\n summary_str = sess.run(summary_op, feed_dict=feed_dict)\\n summary_writer.add_summary(summary_str, step)\\n\\n if step % 500 == 0:\\n validation_images = validation_set.images\\n validation_labels = validation_set.labels\\n feed_dict = {\\n images_placeholder: validation_images,\\n labels_placeholder: validation_labels\\n }\\n [loss_value, acc_value] = sess.run([model.loss, model.acc], feed_dict=feed_dict)\\n logger.info('(validation)loss: %f, acc: %f' % (loss_value, acc_value))\\n\\n if (step != 0 and step % 10000 == 0) or step + 1 == model_conf.NUM_STEPS:\\n checkpoint_path = os.path.join(model_conf.MODEL_SAVER_DIR, 'model.ckpt')\\n saver.save(sess, checkpoint_path, step)\",\n \"def _train_model(self):\\n raise NotImplementedError()\",\n \"def train_model(self, save_folder: str = \\\"latest_model\\\"):\\n dataset_folder = self.dataset_config[\\\"dataset_folder\\\"]\\n if not path.exists(dataset_folder):\\n raise ValueError(f\\\"Folder {dataset_folder} is not exists\\\")\\n\\n files_list = [path.join(dataset_folder, f) for f in listdir(dataset_folder) if path.isfile(path.join(dataset_folder, f)) and f.endswith(\\\".yml\\\")]\\n\\n df, _, _, synonym_dict = make_dataframe(files=files_list)\\n\\n self.synonym_dict.update(synonym_dict)\\n self.config[\\\"model\\\"][\\\"synonym\\\"] = self.synonym_dict\\n\\n dataset = DIETClassifierDataset(dataframe=df, tokenizer=self.tokenizer, entities=self.entities[1:], intents=self.intents)\\n\\n trainer = DIETTrainer(model=self.model, dataset=dataset,\\n train_range=self.training_config[\\\"train_range\\\"],\\n num_train_epochs=self.training_config[\\\"num_train_epochs\\\"],\\n per_device_train_batch_size=self.training_config[\\\"per_device_train_batch_size\\\"],\\n per_device_eval_batch_size=self.training_config[\\\"per_device_eval_batch_size\\\"],\\n warmup_steps=self.training_config[\\\"warmup_steps\\\"],\\n weight_decay=self.training_config[\\\"weight_decay\\\"],\\n logging_dir=self.training_config[\\\"logging_dir\\\"],\\n early_stopping_patience=self.training_config[\\\"early_stopping_patience\\\"],\\n early_stopping_threshold=self.training_config[\\\"early_stopping_threshold\\\"],\\n output_dir=self.training_config[\\\"output_dir\\\"])\\n\\n trainer.train()\\n\\n self.save_pretrained(directory=save_folder)\",\n \"def trainModel(self, train_set_path, test_set_path, img_shape, output_dir, batch_size=32, num_epochs=25):\\n\\n train_datagen = ImageDataGenerator(\\n # Random transform - Data augmenting\\n rescale=1. / 255,\\n shear_range=0.2,\\n zoom_range=0.2,\\n horizontal_flip=True)\\n\\n test_datagen = ImageDataGenerator(rescale=1. / 255)\\n\\n training_set = train_datagen.flow_from_directory(\\n train_set_path,\\n target_size=(img_shape, img_shape),\\n batch_size=32,\\n class_mode='categorical')\\n\\n test_set = test_datagen.flow_from_directory(\\n test_set_path,\\n target_size=(img_shape, img_shape),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n\\n # Saves the model weights after each epoch if the validation loss decreased\\n now = datetime.now()\\n nowstr = 'CNN_Model'\\n\\n now = os.path.join(output_dir, nowstr)\\n\\n # Make the directory\\n os.makedirs(now, exist_ok = True)\\n\\n # Create callbacks\\n savepath = os.path.join(now, 'CNN_Model.h5')\\n checkpointer = ModelCheckpoint(filepath=savepath, monitor='val_acc', mode='max', verbose=0, save_best_only=True)\\n fout = open(os.path.join(now, 'labels.txt'), 'wt')\\n\\n # Write labels to file\\n for key, val in training_set.class_indices.items():\\n fout.write(str(key + '\\\\n'))\\n\\n self.model.fit_generator(\\n training_set,\\n steps_per_epoch=len(training_set.filenames) // batch_size,\\n epochs=num_epochs,\\n validation_data=test_set,\\n validation_steps=len(test_set.filenames) // batch_size,\\n callbacks=[checkpointer])\",\n \"def train_model():\\n # Decode the request\\n data = request.data.decode(\\\"utf-8\\\")\\n\\n # Write data from the request in a local csv file\\n train_csv = \\\"train_local.csv\\\"\\n f = open(train_csv, \\\"w\\\", encoding=\\\"utf-8\\\")\\n f.write(data)\\n f.close()\\n\\n # Load the train csv file as a DataFrame\\n train_df = pd.read_csv(train_csv)\\n\\n # Train model\\n model.train_model(train_df)\\n\\n return jsonify({\\\"success\\\": \\\"The model was trained sucessfully\\\"})\",\n \"def fit(self,X_train,y_train):\\r\\n \\r\\n self.X_train_data=X_train.reset_index(drop=True)\\r\\n self.y_train_data=y_train.reset_index(drop=True)\\r\\n \\r\\n temp_fitted_model=[]\\r\\n for each_model in self.model_list:\\r\\n each_model.fit(self.X_train_data,self.y_train_data)\\r\\n temp_fitted_model.append(each_model)\\r\\n \\r\\n self.fitted_model=temp_fitted_model\",\n \"def training(self):\\n \\n best_valid_loss = np.inf\\n c = 0\\n \\n self.train_loader, self.test_loader = self.get_train_test_loaders()\\n \\n print('Training the {} model with the following architecture:'.format(self.model_name))\\n print(summary(self.model, (3, self.image_width, self.image_height)))\\n print('*'*100)\\n print('Starting the training...')\\n print('*'*100)\\n \\n # Create the model save dir if it already doesn't exist\\n if not os.path.exists(self.model_save_dir):\\n os.makedirs(self.model_save_dir)\\n \\n for epoch in range(self.n_epochs):\\n\\n print(f'Epoch: {epoch+1:02}')\\n\\n start_time = time.time()\\n\\n train_loss = self.train(self.train_loader)\\n valid_loss = self.evaluate(self.test_loader)\\n\\n epoch_mins, epoch_secs = self.epoch_time(start_time, time.time())\\n\\n c+=1\\n if valid_loss < best_valid_loss:\\n best_valid_loss = valid_loss\\n torch.save(self.model.state_dict(), os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)))\\n c=0\\n\\n if c>4:\\n #decrease lr if loss does not decrease after 5 steps\\n self.scheduler.step()\\n c=0\\n\\n print(f'Time: {epoch_mins}m {epoch_secs}s') \\n print(f'Train Loss: {train_loss:.3f}')\\n print(f'Val Loss: {valid_loss:.3f}')\\n print('-'*60)\\n print('The best validation loss is', best_valid_loss)\\n print('*'*100)\",\n \"def train_model(self,model):\\r\\n \\r\\n train_state = {'stop_early': False,\\r\\n 'early_stopping_step': 0,\\r\\n 'early_stopping_best_val': 1e8,\\r\\n 'learning_rate': self.lr,\\r\\n 'epoch_index': 0,\\r\\n 'train_loss': [],\\r\\n 'val_loss': [],\\r\\n 'best_model':model}\\r\\n \\r\\n dataset = self.dataset\\r\\n loss_fn = self.loss_fn\\r\\n \\r\\n dataset.set_split('train')\\r\\n print(\\\"Training module with \\\"+str(len(dataset))+\\\" examples\\\")\\r\\n \\r\\n data_loader = DataLoader(dataset,batch_size=self.batch_size,shuffle=True,\\r\\n drop_last=True)\\r\\n \\r\\n optimizer = optim.Adam(model.parameters(), lr=self.lr)\\r\\n \\r\\n for epoch in range(self.epochs):\\r\\n train_state['epoch_index'] = epoch\\r\\n #First step in each epoch is to train over all batches\\r\\n model.train()\\r\\n dataset.set_split('train')\\r\\n train_loss = 0\\r\\n for b_i,batch_data in enumerate(data_loader):\\r\\n #Step 1: zero gradients\\r\\n optimizer.zero_grad()\\r\\n #Step 2: run forward\\r\\n X = batch_data['x']\\r\\n output = model(X)\\r\\n #Step 3: compute loss\\r\\n target = batch_data['y']\\r\\n loss = loss_fn(output,target)\\r\\n #Step 4: run backward\\r\\n loss.backward()\\r\\n #Step 5: update\\r\\n optimizer.step()\\r\\n \\r\\n #Record accumulated loss\\r\\n new_loss = loss.item()\\r\\n train_loss += new_loss\\r\\n \\r\\n train_loss /= b_i\\r\\n train_state['train_loss'].append(train_loss)\\r\\n \\r\\n #After training, compute loss on validation set and check for early stop\\r\\n model.eval()\\r\\n dataset.set_split('val')\\r\\n val_loss = 0\\r\\n for b_i,batch_data in enumerate(data_loader):\\r\\n #Step 1: run forward\\r\\n X = batch_data['x']\\r\\n output = model(X)\\r\\n #Step 2: compute loss\\r\\n target = batch_data['y']\\r\\n loss = loss_fn(output,target)\\r\\n \\r\\n #Record accumulated loss\\r\\n new_loss = loss.item()\\r\\n val_loss += new_loss\\r\\n \\r\\n val_loss /= b_i\\r\\n train_state['val_loss'].append(val_loss)\\r\\n \\r\\n print(\\\"Finished epoch \\\"+str(epoch+1)+\\\". Train loss=\\\"+\\\\\\r\\n str(train_loss)+\\\", Val loss=\\\"+str(val_loss))\\r\\n \\r\\n if val_loss < train_state['early_stopping_best_val']:\\r\\n #new best model, reset stopping counter, store model\\r\\n train_state['early_stopping_step'] = 0\\r\\n train_state['early_stopping_best_val'] = val_loss\\r\\n best_model = copy.deepcopy(model)\\r\\n best_model.load_state_dict(model.state_dict())\\r\\n train_state['best_model'] = best_model\\r\\n else:\\r\\n #val loss not improved; increase early stopping counter\\r\\n train_state['early_stopping_step'] += 1\\r\\n if train_state['early_stopping_step'] >= self.early_stopping_criteria:\\r\\n train_state['stop_early'] = True\\r\\n print(\\\"Val loss failed to improve. Stopping early.\\\")\\r\\n break\\r\\n \\r\\n return train_state['best_model'],train_state\",\n \"def train(self, x_data, y_data):\\n self.model.fit(np.array(x_data), np.array(y_data),\\n batch_size=2,\\n epochs=3,\\n verbose=1)\\n self.model.save_weights(self.model_filename)\",\n \"def train(self) -> None:\\n\\n # Check if in the saved model path there is already a trained model\\n if self.config.TRN_HYPERP[\\\"save_path\\\"]:\\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\\\"save_path\\\"]):\\n print(\\\"INFO: An existing saved model will be used for inference\\\\n\\\")\\n else:\\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\\n trainer = Trainer(**params)\\n\\n print(f\\\"INFO: Starting training ... \\\\n\\\")\\n start_time = time.time()\\n trainer.train()\\n print(f\\\"\\\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\\\n\\\")\\n\\n # Instantiate the saved translator for inference\\n saved_path = self.config.TRN_HYPERP[\\\"save_path\\\"]\\n self.saved_translator = tf.saved_model.load(saved_path)\\n else:\\n print(\\\"INFO: Path to save model wasn't provided in config file. Can't train the model\\\\n\\\")\",\n \"def train(self, training_data):\\n pass\",\n \"def train(self, tr_set_path: str, save_path: str, va_split: float=0.1, stratified_split: bool=False, early_stopping: bool=True):\\n df_tr = read_csv_json(tr_set_path)\\n if stratified_split:\\n df_va = df_tr.groupby('intent').apply(lambda g: g.sample(frac=va_split, random_state=SEED))\\n df_tr = df_tr[~df_tr.index.isin(df_va.index.get_level_values(1))]\\n va_messages, va_labels = list(df_va.text), list(df_va.intent)\\n va_dataset = [{'data': va_messages[i], 'label': va_labels[i]} for i in range(len(df_va))]\\n tr_messages, tr_labels = list(df_tr.text), list(df_tr.intent)\\n tr_dataset = [{'data': tr_messages[i], 'label': tr_labels[i]} for i in range(len(df_tr))]\\n (x_train, y_train, le_encoder) = self.__preprocess(tr_dataset)\\n (x_va, y_va, _) = self.__preprocess(va_dataset, le_encoder)\\n else:\\n tr_messages, tr_labels = list(df_tr.text), list(df_tr.intent)\\n tr_dataset = [{'data': tr_messages[i], 'label': tr_labels[i]} for i in range(len(df_tr))]\\n (x_train, y_train, le_encoder) = self.__preprocess(tr_dataset)\\n\\n K.clear_session()\\n graph = tf.Graph()\\n with graph.as_default():\\n session = tf.Session()\\n with session.as_default():\\n session.run(tf.global_variables_initializer())\\n model = self.__build_model(num_classes=len(le_encoder.categories_[0]))\\n model.compile(\\n loss=losses.CategoricalCrossentropy(label_smoothing=self.label_smoothing),\\n #metrics=['categorical_accuracy'],\\n optimizer=self.model_cfg.get('optimizer', 'adam') #default lr at 0.001\\n #optimizer=optimizers.Adam(learning_rate=5e-4)\\n )\\n # early stopping callback using validation loss \\n callback = tf.keras.callbacks.EarlyStopping(\\n monitor=\\\"val_loss\\\",\\n min_delta=0,\\n patience=5,\\n verbose=0,\\n mode=\\\"auto\\\",\\n baseline=None,\\n restore_best_weights=True,\\n )\\n #callback = EarlyStoppingAtMaxMacroF1(\\n # patience=100, # record all epochs\\n # validation=(x_va, y_va)\\n #)\\n\\n print('start training')\\n history = model.fit(x_train, y_train,\\n batch_size=self.model_cfg['batch_size'],\\n epochs=100,\\n validation_split=va_split if not stratified_split else 0,\\n validation_data=(x_va, y_va) if stratified_split else None,\\n callbacks=[callback] if early_stopping else None)\\n history.history['train_data'] = tr_set_path\\n print(f'finished training in {len(history.history[\\\"loss\\\"])} epochs')\\n save(model, le_encoder, save_path, history)\\n self.model = model\\n self.session = session\\n self.graph = graph\\n self.le_encoder = le_encoder\\n # return training history \\n return history.history\",\n \"def train_model(net, model_name, max_epochs=50, patience=7, batch_size=256, overwrite=False):\\n file_exists = os.path.isfile(_get_model_file(CHECKPOINT_PATH, model_name))\\n if file_exists and not overwrite:\\n print(\\\"Model file already exists. Skipping training...\\\")\\n else:\\n if file_exists:\\n print(\\\"Model file exists, but will be overwritten...\\\")\\n\\n # Defining optimizer, loss and data loader\\n optimizer = optim.SGD(net.parameters(), lr=1e-2, momentum=0.9) # Default parameters, feel free to change\\n loss_module = nn.CrossEntropyLoss()\\n train_loader_local = data.DataLoader(\\n train_set, batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True\\n )\\n\\n val_scores = []\\n best_val_epoch = -1\\n for epoch in range(max_epochs):\\n ############\\n # Training #\\n ############\\n net.train()\\n true_preds, count = 0.0, 0\\n for imgs, labels in tqdm(train_loader_local, desc=f\\\"Epoch {epoch+1}\\\", leave=False):\\n imgs, labels = imgs.to(device), labels.to(device) # To GPU\\n optimizer.zero_grad() # Zero-grad can be placed anywhere before \\\"loss.backward()\\\"\\n preds = net(imgs)\\n loss = loss_module(preds, labels)\\n loss.backward()\\n optimizer.step()\\n # Record statistics during training\\n true_preds += (preds.argmax(dim=-1) == labels).sum()\\n count += labels.shape[0]\\n train_acc = true_preds / count\\n\\n ##############\\n # Validation #\\n ##############\\n val_acc = test_model(net, val_loader)\\n val_scores.append(val_acc)\\n print(\\n f\\\"[Epoch {epoch+1:2i}] Training accuracy: {train_acc*100.0:05.2f}%, Validation accuracy: {val_acc*100.0:05.2f}%\\\"\\n )\\n\\n if len(val_scores) == 1 or val_acc > val_scores[best_val_epoch]:\\n print(\\\"\\\\t (New best performance, saving model...)\\\")\\n save_model(net, CHECKPOINT_PATH, model_name)\\n best_val_epoch = epoch\\n elif best_val_epoch <= epoch - patience:\\n print(f\\\"Early stopping due to no improvement over the last {patience} epochs\\\")\\n break\\n\\n # Plot a curve of the validation accuracy\\n plt.plot([i for i in range(1, len(val_scores) + 1)], val_scores)\\n plt.xlabel(\\\"Epochs\\\")\\n plt.ylabel(\\\"Validation accuracy\\\")\\n plt.title(f\\\"Validation performance of {model_name}\\\")\\n plt.show()\\n plt.close()\\n\\n load_model(CHECKPOINT_PATH, model_name, net=net)\\n test_acc = test_model(net, test_loader)\\n print((f\\\" Test accuracy: {test_acc*100.0:4.2f}% \\\").center(50, \\\"=\\\") + \\\"\\\\n\\\")\\n return test_acc\",\n \"def train(self):\\n if self.retrain:\\n self.states = self.get_states()\\n self.transitions = self.get_transitions()\\n self.matrix = self.get_matrix()\\n self.save_training()\\n else:\\n self.load_training()\",\n \"def train_model(self, initial=False):\\n if len(self.loading.intersection({'model_train', 'base_model'})) > 0:\\n return\\n\\n train_files = []\\n if not self.model_trained and not initial:\\n train_files = list(askopenfilenames())\\n if len(train_files) is 0:\\n return\\n\\n self.queue_gui_update('model_train_status', {'visible': False})\\n self.queue_gui_update('btn_train_model', {'text': 'Training...'})\\n self.queue_gui_update('model_train_loading', {'visible': True})\\n self.loading.add('model_train')\\n else:\\n self.queue_gui_update('base_model_status', {'visible': False})\\n self.queue_gui_update('btn_train_model', {'text': 'Loading base model...'})\\n self.queue_gui_update('base_model_loading', {'visible': True})\\n self.loading.add('base_model')\\n\\n\\n self.model, is_base = get_model(train_files)\\n if is_base or is_base is None:\\n self.base_model_loaded = True\\n self.model_trained = False\\n self.queue_gui_update('base_model_status', {'value': u'\\\\u2713', 'text_color': 'green', 'visible': True})\\n self.queue_gui_update('base_model_loading', {'visible': False})\\n\\n self.queue_gui_update('model_train_status', {'value': u'\\\\u2717', 'text_color': 'red', 'visible': True})\\n self.queue_gui_update('btn_train_model', {'text': 'Train transfer model'})\\n self.queue_gui_update('model_train_loading', {'visible': False})\\n\\n if is_base:\\n self.loading.remove('base_model')\\n else:\\n self.model_trained = True\\n self.queue_gui_update('model_train_status', {'value': u'\\\\u2713', 'text_color': 'green', 'visible': True})\\n self.queue_gui_update('btn_train_model', {'text': 'Reset model'})\\n self.queue_gui_update('model_train_loading', {'visible': False})\\n self.loading.remove('model_train')\\n\\n self.model._make_predict_function()\",\n \"def model_switch_to_training(self):\\n pass\",\n \"def train(self, model_type, params=None):\\n Model = load_model_class(model_type)\\n self.model_type = model_type\\n X, y = self.task.make_dataset()\\n self.final_data = X.copy()\\n # Save preds\\n preds = np.zeros_like(y.values).astype(np.float)\\n with TMPFolder():\\n N = len(X)\\n n = N // self.cv\\n # Assign a fold to each sample\\n folds = np.random.permutation(np.repeat(np.arange(self.cv), n+1)[:N])\\n if self.cv == 1:\\n folds[:] = 1\\n folds[np.random.permutation(np.arange(N))[:int(round(0.25 * N))]] = 0\\n # Iterate over folds\\n for k in range(self.cv):\\n print(\\\"Fold\\\", k)\\n # Create model\\n model = Model()\\n if params is not None:\\n model.set_hp(params)\\n # Create sub-dataset\\n X_train = X[folds != k]\\n y_train = y[folds != k]\\n X_test = X[folds == k]\\n y_test = y[folds == k]\\n # Train the model\\n model.train(X_train, y_train)\\n # Make predictions on test samples\\n y_pred = model.predict(X_test)\\n # Save the predictions\\n preds[folds == k] = y_pred\\n self.model_save.append(model)\\n # Save folds\\n self.folds = folds\\n self.is_trained = True\\n self.preds = preds\\n self.true_labels = y\",\n \"def train(self):\\n # Change directory to the code directory\\n current_working_directory = os.getcwd()\\n\\n os.chdir(self.model_parameters[\\\"NN_code_directory\\\"])\\n\\n self.call_training_routine()\\n\\n # Come back to the original directory\\n os.chdir(current_working_directory)\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def retrain(datapath, model_version):\\n df = get_df(datapath)\\n X = df.drop(columns='target')\\n y = df['target']\\n fitted_model = fit(RF, X, y)\\n\\n with open(f'trained_models/model_{model_version}.joblib', 'wb') as file:\\n joblib.dump(fitted_model, file)\",\n \"def train_val_training(X_train, y_train, model):\\n # set pach where trained models will be saved to \\n savepath = Path('/home/kwaygo/Documents/NUS/SPH6004/P2/SPH6004_P2/models/Regression')\\n checkpoint_name = os.path.join(savepath, 'Weights-{epoch:03d}--{val_loss:.5f}.hdf5' ) \\n # define callbacks\\n cp = ModelCheckpoint(checkpoint_name, monitor='val_loss', verbose = 1, save_best_only = True, mode ='auto')\\n es = EarlyStopping(monitor='val_loss', patience= 4, verbose=1)\\n callbacks_list = [es, cp]\\n # start training\\n hist = model.fit(X_train, y_train, epochs=500, batch_size=500, validation_split = 0.2, callbacks=callbacks_list) \\n \\n print(\\\"[INFO] avg. ICU LOS of train set: {}, std ICU LOS of test set: {}\\\".format(np.mean(y_train), np.std(y_train)))\\n # plot training History \\n plotHist(hist)\\n return model\",\n \"def train_and_eval(self):\\n self.__create_indexes()\\n model = None\\n model = None\\n if self.model == 'OMult':\\n model = OMult(self.kwargs)\\n elif self.model == 'ConvO':\\n model = ConvO(self.kwargs)\\n elif self.model == 'QMult':\\n model = QMult(self.kwargs)\\n elif self.model == 'ConvQ':\\n model = ConvQ(self.kwargs)\\n elif self.model == 'OMultBatch':\\n model = OMultBatch(self.kwargs)\\n elif self.model == 'ConvOBatch':\\n model = ConvOBatch(self.kwargs)\\n elif self.model == 'QMultBatch':\\n model = QMultBatch(self.kwargs)\\n elif self.model == 'ConvQBatch':\\n model = ConvQBatch(self.kwargs)\\n else:\\n print(self.model, ' is not valid name')\\n raise ValueError\\n\\n self.train(model)\\n self.eval(model)\",\n \"def train(self, trainset, testset, niter=1000, ntest=300, epochs=int(1e6)):\\n\\n print('\\\\n>> Training begins!\\\\n')\\n\\n def fetch_dict(datagen, keep_prob=0.5):\\n \\\"\\\"\\\"Format model input data.\\\"\\\"\\\"\\n bx, by, br = next(datagen)\\n while not (bx.shape[0] > 0 and bx.shape[1] > 0):\\n bx, by, br = next(datagen)\\n\\n dec_lengths = np.full((bx.shape[0], ), bx.shape[1], dtype=np.int32)\\n\\n feed_dict = {\\n self.xs_: bx,\\n self.ys_: by,\\n self.dec_inputs_length_: dec_lengths,\\n self.ext_context_: br,\\n self.keep_prob_: keep_prob\\n }\\n return feed_dict\\n\\n # setup session\\n sess = tf.Session()\\n sess.run(tf.global_variables_initializer())\\n\\n load_classification_parameters(\\n sess, \\\"models/model.ckpt-1500000\\\", \\\"class\\\")\\n load_classification_parameters(\\n sess, \\\"models/model.ckpt-1500000\\\", \\\"feat\\\")\\n\\n # get last checkpoint\\n saver = tf.train.Saver(get_collections([\\\"encoder\\\", \\\"decoder\\\", \\\"proj\\\"]))\\n ckpt = tf.train.get_checkpoint_state(self.ckpt_path)\\n # verify it\\n if ckpt and ckpt.model_checkpoint_path:\\n try:\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n except tf.OpError:\\n # graph structure changed, cannot load, restart training\\n pass\\n\\n try:\\n # start training\\n for j in range(epochs):\\n mean_loss = 0\\n for n_it in range(niter):\\n _, loss = sess.run(\\n [self.train_op, self.loss],\\n feed_dict=fetch_dict(trainset))\\n mean_loss += loss\\n print(' [{}/{}]\\\\r'.format(n_it, niter))\\n\\n print('[{}] train loss : {}'.format(j, mean_loss / niter))\\n saver.save(sess, self.ckpt_path + self.model_name + '.ckpt',\\n global_step=j)\\n\\n # evaluate\\n testloss = 0\\n for _ in range(ntest):\\n testloss += sess.run(\\n [self.loss],\\n feed_dict=fetch_dict(testset, keep_prob=1.))[0]\\n print('test loss : {}'.format(testloss / ntest))\\n\\n except KeyboardInterrupt:\\n print('\\\\n>> Interrupted by user at iteration {}'.format(j))\",\n \"def train_model(self):\\n self.best_epoch = {'auto':{}, 'coffee':{}, 'movie':{}, 'pizza':{}, 'restaurant':{}, 'uber':{} }\\n self.best_f1 = {'auto':{}, 'coffee':{}, 'movie':{}, 'pizza':{}, 'restaurant':{}, 'uber':{} }\\n for t in self.topic:\\n if t != 'other':\\n for st in self.topic2sub_topic[t].keys():\\n\\n print(\\\"Now training the classsfier for topic: \\\", t, \\\" ; intent: \\\", st)\\n print(128 * \\\"=\\\")\\n print(\\\"Input: str; Output: boolean(if the str contents the intent: \\\", st, \\\" ).\\\")\\n print(64 * \\\"-\\\")\\n X, y = self.get_data(t, st)\\n print(\\\"data_loaded!\\\")\\n X_train, X_dev, y_train, y_dev = self.my_train_test_split(X, y)\\n best_f1 = 0\\n for e in range(1,10):\\n model = tf.keras.Sequential()\\n model.add(tf.keras.layers.InputLayer(input_shape=[1024, ]))\\n model.add(tf.keras.layers.Dense(64, activation='relu'))\\n model.add(tf.keras.layers.Dense(64, activation='relu'))\\n model.add(tf.keras.layers.Dense(1, activation='relu'))\\n model.compile(loss='mean_squared_logarithmic_error', optimizer='adam', metrics=[metrics.mae, metrics.categorical_accuracy])\\n model.fit(X_train, y_train, epochs=e, batch_size=128)\\n print(\\\"f1_score on dev set: \\\")\\n f1 = self.f1_score_model(model, X_dev, y_dev)[0]\\n if f1 > best_f1:\\n self.model_zoo[t][st] = model\\n model.save_weights(self.trained_w_folder+\\\"/%s/%s.h5\\\" %(t,st))\\n self.best_epoch[t][st] = e\\n self.best_f1[t][st] = f1\\n best_f1 = f1\\n\\n print(64*\\\"=\\\")\\n print()\",\n \"def fit(self):\\n \\n # Open an existing model and get the training & test dataset and targets\\n train_test_df, target_df = self._get_model_and_data(target=True, set_feature_def=True)\\n \\n # Check that the estimator is an supervised ML algorithm\\n if self.model.estimator_type not in [\\\"classifier\\\", \\\"regressor\\\"]:\\n err = \\\"Incorrect usage. The estimator specified is not a known classifier or regressor: {0}\\\".format(self.model.estimator)\\n raise Exception(err)\\n \\n # Check which validation strategy is to be used, if any\\n # For an explanation of cross validation in scikit-learn see: http://scikit-learn.org/stable/modules/cross_validation.html#multimetric-cross-validation\\n if self.model.time_series_split > 0:\\n self.model.validation = \\\"timeseries\\\"\\n # Set up cross validation to be performed using TimeSeriesSplit\\n self.model.cv = TimeSeriesSplit(n_splits=self.model.time_series_split, max_train_size=self.model.max_train_size)\\n elif self.model.cv > 0:\\n self.model.validation = \\\"k-fold\\\"\\n elif self.model.test_size > 0:\\n self.model.validation = \\\"hold-out\\\"\\n else:\\n self.model.validation = \\\"external\\\"\\n\\n if self.model.validation == \\\"hold-out\\\": \\n # Split the data into training and testing subsets\\n self.X_train, self.X_test, self.y_train, self.y_test = \\\\\\n train_test_split(train_test_df, target_df, test_size=self.model.test_size, random_state=self.model.random_state)\\n else:\\n self.X_train = train_test_df\\n self.y_train = target_df\\n \\n # Add the training and test data to the model if required\\n if self.model.retain_data:\\n self.model.X_train = self.X_train\\n self.model.y_train = self.y_train\\n \\n try:\\n self.model.X_test = self.X_test\\n self.model.y_test = self.y_test\\n except AttributeError:\\n pass\\n \\n # Scale the targets and increase stationarity if required\\n if self.model.scale_target or self.model.make_stationary:\\n # Set up the target transformer\\n self.model.target_transformer = TargetTransformer(scale=self.model.scale_target, make_stationary=self.model.make_stationary, stationarity_lags=self.model.stationarity_lags,\\\\\\n missing=self.model.missing, scaler=self.model.scaler, logfile=self.logfile, **self.model.scaler_kwargs)\\n\\n # Fit the transformer to the training targets\\n self.model.target_transformer = self.model.target_transformer.fit(self.y_train)\\n\\n # Apply the transformer to the training targets\\n self.y_train = self.model.target_transformer.transform(self.y_train)\\n # Drop samples where the target cannot be transformed due to insufficient lags\\n self.X_train = self.X_train.iloc[len(self.X_train)-len(self.y_train):] \\n \\n # Add lag observations to the samples if required\\n if self.model.lags or self.model.lag_target:\\n # Check if the current sample will be included as an input, or whether we only use lag observations for predictions\\n extrapolate = 1 if self.model.current_sample_as_input else 0\\n # Add the lag observations\\n self.X_train = self._add_lags(self.X_train, self.y_train, extrapolate=extrapolate, update_features_df=True)\\n # Drop targets for samples which were dropped due to null values after adding lags.\\n if len(self.y_train) > len(self.X_train):\\n self.y_train = self.y_train.iloc[len(self.y_train)-len(self.X_train):]\\n\\n # If this is a Keras estimator, we require the preprocessing to return a data frame instead of a numpy array\\n prep_return = 'df' if self.model.using_keras else 'np'\\n\\n # Construct the preprocessor\\n prep = Preprocessor(self.model.features_df, return_type=prep_return, scale_hashed=self.model.scale_hashed, scale_vectors=self.model.scale_vectors,\\\\\\n missing=self.model.missing, scaler=self.model.scaler, logfile=self.logfile, **self.model.scaler_kwargs)\\n\\n # Setup a list to store steps for the sklearn pipeline\\n pipe_steps = [('preprocessor', prep)]\\n\\n if self.model.dim_reduction:\\n # Construct the dimensionality reduction object\\n reduction = self.decomposers[self.model.reduction](**self.model.dim_reduction_args)\\n \\n # Include dimensionality reduction in the pipeline steps\\n pipe_steps.append(('reduction', reduction))\\n self.model.estimation_step = 2\\n else:\\n self.model.estimation_step = 1 \\n\\n # If this is a Keras estimator, update the input shape and reshape the data if required\\n if self.model.using_keras:\\n # Update the input shape based on the final number of features after preprocessing\\n self._keras_update_shape(prep)\\n\\n # Add the Keras build function, architecture and prediction_periods to the estimator keyword arguments\\n self.model.estimator_kwargs['build_fn'] = self._keras_build_fn\\n self.model.estimator_kwargs['architecture'] = self.model.architecture\\n self.model.estimator_kwargs['prediction_periods'] = self.model.prediction_periods\\n\\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(10)\\n \\n # Check than an identifier has been provided for sorting data if this is a sequence prediction problem\\n if self.model.lags or len(self.model.first_layer_kwargs[\\\"input_shape\\\"]) > 1:\\n assert len(self.model.original_features_df[self.model.original_features_df['variable_type'].isin([\\\"identifier\\\"])]) == 1, \\\\\\n \\\"An identifier is mandatory when using lags or with sequence prediction problems. Define this field in your feature definitions.\\\"\\n\\n # Cater for multi-step predictions\\n if self.model.prediction_periods > 1:\\n # Transform y to a vector of values equal to prediction_periods\\n self.y_train = utils.vectorize_array(self.y_train, steps=self.model.prediction_periods)\\n # Drop values from x for which we don't have sufficient y values\\n self.X_train = self.X_train.iloc[:-len(self.X_train)+len(self.y_train)]\\n\\n # Add a pipeline step to update the input shape and reshape the data if required\\n # This transform will also add lag observations if specified through the lags parameter\\n # If lag_target is True, an additional feature will be created for each sample using the previous value of y \\n reshape = Reshaper(first_layer_kwargs=self.model.first_layer_kwargs, logfile=self.logfile)\\n pipe_steps.append(('reshape', reshape))\\n self.model.estimation_step += self.model.estimation_step\\n\\n # Avoid tensorflow error for keras models\\n # https://github.com/tensorflow/tensorflow/issues/14356\\n # https://stackoverflow.com/questions/40785224/tensorflow-cannot-interpret-feed-dict-key-as-tensor\\n kerasbackend.clear_session()\\n \\n # Try assuming the pipeline involves a grid search\\n try:\\n # Construct an estimator\\n estimator = self.algorithms[self.model.estimator](**self.model.estimator_kwargs)\\n\\n # Prepare the grid search using the previously set parameter grid\\n grid_search = GridSearchCV(estimator=estimator, param_grid=self.model.param_grid, **self.model.grid_search_args)\\n \\n # Add grid search to the pipeline steps\\n pipe_steps.append(('grid_search', grid_search))\\n\\n # Construct the sklearn pipeline using the list of steps\\n self.model.pipe = Pipeline(pipe_steps)\\n\\n if self.model.validation in [\\\"k-fold\\\", \\\"timeseries\\\"]:\\n # Perform K-fold cross validation\\n self._cross_validate()\\n\\n # Fit the training data to the pipeline\\n if self.model.using_keras:\\n # https://stackoverflow.com/questions/54652536/keras-tensorflow-backend-error-tensor-input-10-specified-in-either-feed-de\\n session = tf.Session()\\n kerasbackend.set_session(session)\\n with session.as_default():\\n with session.graph.as_default():\\n sys.stdout.write(\\\"\\\\nMODEL: {}, INPUT SHAPE: {}\\\\n\\\\n\\\".format(self.model.name, self.model.first_layer_kwargs['input_shape']))\\n y = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\\n self.model.pipe.fit(self.X_train, y)\\n else:\\n self.model.pipe.fit(self.X_train, self.y_train.values.ravel())\\n\\n # Get the best parameters and the cross validation results\\n grid_search = self.model.pipe.named_steps['grid_search']\\n self.model.best_params = grid_search.best_params_\\n self.model.cv_results = grid_search.cv_results_\\n\\n # Get the best estimator to add to the final pipeline\\n estimator = grid_search.best_estimator_\\n\\n # Update the pipeline with the best estimator\\n self.model.pipe.steps[self.model.estimation_step] = ('estimator', estimator)\\n\\n except AttributeError:\\n # Construct an estimator\\n estimator = self.algorithms[self.model.estimator](**self.model.estimator_kwargs)\\n\\n # Add the estimator to the pipeline steps\\n pipe_steps.append(('estimator', estimator))\\n\\n # Construct the sklearn pipeline using the list of steps\\n self.model.pipe = Pipeline(pipe_steps)\\n\\n if self.model.validation in [\\\"k-fold\\\", \\\"timeseries\\\"]:\\n # Perform K-fold cross validation\\n self._cross_validate()\\n\\n # Fit the training data to the pipeline\\n if self.model.using_keras:\\n # https://stackoverflow.com/questions/54652536/keras-tensorflow-backend-error-tensor-input-10-specified-in-either-feed-de\\n session = tf.Session()\\n kerasbackend.set_session(session)\\n with session.as_default():\\n with session.graph.as_default():\\n sys.stdout.write(\\\"\\\\nMODEL: {}, INPUT SHAPE: {}\\\\n\\\\n\\\".format(self.model.name, self.model.first_layer_kwargs['input_shape']))\\n y = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\\n self.model.pipe.fit(self.X_train, y)\\n else:\\n self.model.pipe.fit(self.X_train, self.y_train.values.ravel())\\n \\n if self.model.validation == \\\"hold-out\\\": \\n # Evaluate the model using the test data \\n self.calculate_metrics(caller=\\\"internal\\\")\\n \\n if self.model.calc_feature_importances:\\n # Select the dataset for calculating importances\\n if self.model.validation == \\\"hold-out\\\":\\n X = self.X_test\\n y = self.y_test # Already a numpy array after calculate_metrics\\n else:\\n X = self.X_train\\n y = self.y_train.values.ravel()\\n \\n # Calculate model agnostic feature importances\\n self._calc_importances(X = X, y = y)\\n\\n # Persist the model to disk\\n self.model = self.model.save(self.model.name, self.path, overwrite=self.model.overwrite, compress=self.model.compress)\\n \\n # Update the cache to keep this model in memory\\n self._update_cache()\\n \\n # Prepare the output\\n if self.model.validation != \\\"external\\\": \\n message = [[self.model.name, 'Model successfully trained, tested and saved to disk.',\\\\\\n time.strftime('%X %x %Z', time.localtime(self.model.state_timestamp)),\\\\\\n \\\"{0} model has a score of {1:.3f} against the test data.\\\"\\\\\\n .format(self.model.estimator, self.model.score), self.model.score]]\\n else:\\n message = [[self.model.name, 'Model successfully trained and saved to disk.',\\\\\\n time.strftime('%X %x %Z', time.localtime(self.model.state_timestamp)),\\\\\\n \\\"{0} model score unknown as test_size was <= 0.\\\"\\\\\\n .format(self.model.estimator), np.NaN]]\\n \\n self.response = pd.DataFrame(message, columns=['model_name', 'result', 'time_stamp', 'score_result', 'score'])\\n \\n # Send the reponse table description to Qlik\\n self._send_table_description(\\\"fit\\\")\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n # Finally send the response\\n return self.response\",\n \"def fit(self,\\n X_train,\\n y_train, \\n X_test, \\n y_test):\\n \\n #instantiate path_model_dirs dictionary so we can know where the models are saved\\n self.path_model_dirs = {}\\n\\n for key in self.models_dict.keys():\\n \\n if self.verbose >=1: print('\\\\n----',key,'----')\\n\\n #define model directory\\n path_model_dir = _os.path.join(self.path_GridSearchCV_dir, key)\\n self.path_model_dirs[key] = path_model_dir\\n if self.verbose >=1: print('path_model_dir:',path_model_dir)\\n \\n model_type = type(self.models_dict[key]['model'])\\n if 'sklearn' in str(model_type) or 'xgboost' in str(model_type):\\n path_file = _os.path.join(path_model_dir,'model_dict.dill')\\n elif 'Net' in key:\\n path_file = _os.path.join(path_model_dir,'best_params_.dill')\\n\\n if self.retrain or _os.path.isfile(path_file)==False:\\n self.models_dict[key] = self._single_model_GridSearchCV(self.models_dict[key], \\n X_train, y_train, \\n X_test, y_test,\\n path_model_dir)\\n\\n else: #reload previously trained model\\n if 'sklearn' in str(type(self.models_dict[key]['model'])):\\n self.models_dict[key] = self.load('model_dict', 'dill', path_model_dir)\\n elif 'Net' in key:\\n #check kwargs for epochs\\n epochs = 100\\n for item in self.kwargs.items():\\n if 'epochs' in item[0]: epochs = item[1]\\n self.models_dict[key] = self.load_NeuralNet(path_model_dir, \\n X_train, y_train, \\n epochs)\\n\\n y_pred = self.models_dict[key]['best_model'].predict(X_test)\\n\\n if 'Net' not in key:\\n self.models_dict[key]['best_pred_score'] = self.models_dict[key]['best_model'].score(X_test, y_test)\\n else:\\n self.models_dict[key]['best_pred_score'] = self.models_dict[key]['best_model'].evaluate(X_test, y_test, verbose =0)\\n \\n if self.verbose >=1:\\n print('\\\\tbest_cv_score:',self.models_dict[key]['best_cv_score'])\\n print('\\\\tbest_pred_score:',self.models_dict[key]['best_pred_score'])\\n\\n for metric_key in self.metrics.keys():\\n if self.metrics[metric_key] !=None:\\n try:\\n self.models_dict[key][metric_key] = self.metrics[metric_key](y_test, y_pred)\\n print('\\\\t',metric_key,':',self.models_dict[key][metric_key])\\n except Exception as e:\\n print('Exception occured for',metric_key,':',str(e))\\n\\n if 'sklearn' in str(type(self.models_dict[key]['model'])):\\n self.save(self.models_dict[key], 'model_dict', 'dill', path_model_dir)\\n elif 'Net' in key:\\n model_dict_subset = self.models_dict[key].copy()\\n for key in self.models_dict[key].keys():\\n if key not in ['y_test','y_pred','best_pred_score'] +list(self.metrics.keys()):\\n model_dict_subset.pop(key)\",\n \"def train(self, train_dataset):\\n\\n # check fine_tuning option\\n model_path = os.path.join(self.check_point, 'model.pt')\\n if self.fine_tune and not os.path.exists(model_path):\\n raise Exception('Cannot find %s.' %model_path)\\n elif self.fine_tune and os.path.exists(model_path):\\n if self.verbose:\\n pass\\n self.model = torch.load(model_path)\\n self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)\\n \\n # capture best model\\n best_val_psnr = -1\\n best_model_state = self.model.state_dict()\\n\\n # Train the model\\n for epoch in range(self.num_epochs):\\n self._epoch_step(train_dataset, epoch)\\n self.scheduler.step()\\n\\n\\n\\n # capture running PSNR on train and val dataset\\n train_psnr, train_ssim, _, _ = self._check_PSNR(train_dataset)\\n self.hist_train_psnr.append(train_psnr)\\n \\n\\n \\n # write the model to hard-disk for testing\\n if not os.path.exists(self.check_point):\\n os.makedirs(self.check_point)\\n model_path = os.path.join(self.check_point, 'model.pt')\\n torch.save(self.model, model_path)\",\n \"def train(sess, env, Xdata, ydata, X_valid=None, y_valid=None, epochs=1,\\n load=False, shuffle=True, batch_size=128, name='model'):\\n if load:\\n if not hasattr(env, 'saver'):\\n return print('\\\\nError: cannot find saver op')\\n print('\\\\nLoading saved model')\\n return env.saver.restore(sess, 'model/{}'.format(name))\\n\\n print('\\\\nTrain model')\\n n_sample = Xdata.shape[0]\\n n_batch = int((n_sample+batch_size-1) / batch_size)\\n for epoch in range(epochs):\\n print('\\\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\\n\\n if shuffle:\\n print('\\\\nShuffling data')\\n ind = np.arange(n_sample)\\n np.random.shuffle(ind)\\n Xdata = Xdata[ind]\\n ydata = ydata[ind]\\n\\n for batch in range(n_batch):\\n print(' batch {0}/{1}'.format(batch + 1, n_batch), end='\\\\r')\\n begin = batch * batch_size\\n ending = min(n_sample, begin + batch_size)\\n sess.run(env.train_op, feed_dict={env.x: Xdata[begin:ending],\\n env.y: ydata[begin:ending],\\n env.training: True})\\n if X_valid is not None:\\n evaluate(sess, env, X_valid, y_valid)\\n\\n if hasattr(env, 'saver'):#在此处保存模型吧？\\n print('\\\\n Saving model')\\n os.makedirs('model', exist_ok=True)\\n env.saver.save(sess, 'model/{}'.format(name))\",\n \"def train_model(model, x_train, y_train, x_test, y_test,\\n epochs=None, batch_size=None):\\n\\n # Training\\n if batch_size is None:\\n batch_size = 128\\n if epochs is None:\\n epochs = 20\\n\\n print('x_train shape:', x_train.shape)\\n print('x_test shape:', x_test.shape)\\n\\n print('Train...')\\n model.fit(x_train,\\n y_train,\\n batch_size=batch_size,\\n epochs=epochs,\\n validation_data=(x_test, y_test),\\n use_multiprocessing=True)\",\n \"def save_model(self, epoch):\\n # Set the name for the model\\n gen_lungs_filename = 'gen_lungs_model_epoch_{}.h5'.format(epoch + 1)\\n disc_lungs_filename = 'disc_lungs_model_epoch_{}.h5'.format(epoch + 1)\\n train_summary_lungs_filename = 'train_summary_lungs_epoch_{}.csv'.format(epoch + 1)\\n\\n gen_organs_filename = 'gen_organs_model_epoch_{}.h5'.format(epoch + 1)\\n disc_organs_filename = 'disc_organs_model_epoch_{}.h5'.format(epoch + 1)\\n train_summary_organs_filename = 'train_summary_organs_epoch_{}.csv'.format(epoch + 1)\\n\\n # Save the model and train summary\\n self.generator_lungs.save(op.join(self.model_dir, gen_lungs_filename), include_optimizer=True)\\n self.disc_lungs.save(op.join(self.model_dir, disc_lungs_filename), include_optimizer=True)\\n self.summary_writer_lungs.to_csv(op.join(self.train_summary_dir, train_summary_lungs_filename))\\n\\n self.generator_organs.save(op.join(self.model_dir, gen_organs_filename), include_optimizer=True)\\n self.disc_organs.save(op.join(self.model_dir, disc_organs_filename), include_optimizer=True)\\n self.summary_writer_organs.to_csv(op.join(self.train_summary_dir, train_summary_organs_filename))\\n return self\",\n \"def train(cleaner, data_source, save_to=\\\"../models/model.pkl\\\"):\\n df = pd.read_csv(data_source)\\n df = df[pd.notnull(df['tags'])]\\n print(\\\"Start : Pre-cleaning process . . . \\\")\\n print(\\\" HTML decoding . . . done\\\")\\n print(\\\" lowercase text . . . done\\\")\\n print(\\\" replace [/(){}\\\\[\\\\]\\\\|@,;] symbols by space . . . done\\\")\\n print(\\\" remove remaining symbols . . . done\\\")\\n print(\\\" remove stopwords . . . done\\\")\\n df['post'] = df['post'].apply(cleaner)\\n print(\\\"End : Pre-cleaning process\\\")\\n x = df.post\\n y = df.tags\\n # no need for split data in final training stage\\n # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 42)\\n print(\\\"Start : model creation process . . . \\\")\\n sgd = Pipeline([('vect', CountVectorizer()),\\n ('tfidf', TfidfTransformer()),\\n ('clf', SGDClassifier(loss='hinge', penalty='l2', alpha=1e-3, random_state=42, max_iter=5,\\n tol=None)),\\n ])\\n # sgd.fit(X_train, y_train)\\n sgd.fit(x, y)\\n print(\\\"End : model creation process\\\")\\n model = open(save_to, 'wb')\\n pickle.dump(sgd, model)\\n model.close()\\n print(\\\"Trained model saved to \\\" + save_to)\\n return sgd\",\n \"def train(self, train_set, model, num_epochs=5, resume=False, optimizer=None, dev_set=None):\\n\\n\\t\\ttorch.cuda.empty_cache()\\n\\t\\tself.resume = resume\\n\\t\\tif resume:\\n\\t\\t\\tlatest_checkpoint_path = Checkpoint.get_latest_epoch_checkpoint(self.load_dir)\\n\\t\\t\\tprint('resuming {} ...'.format(latest_checkpoint_path))\\n\\t\\t\\tresume_checkpoint = Checkpoint.load(latest_checkpoint_path)\\n\\t\\t\\tmodel = resume_checkpoint.model\\n\\t\\t\\tself.optimizer = resume_checkpoint.optimizer\\n\\n\\t\\t\\t# check var\\n\\t\\t\\tmodel.set_var('attention_forcing', self.attention_forcing)\\n\\t\\t\\tmodel.set_var('debug_count', 0)\\n\\t\\t\\tmodel.reset_use_gpu(self.use_gpu)\\n\\t\\t\\tprint('attention forcing: {}'.format(model.attention_forcing))\\n\\t\\t\\tprint('use gpu: {}'.format(model.use_gpu))\\n\\t\\t\\tif self.use_gpu:\\n\\t\\t\\t\\tmodel = model.cuda()\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmodel = model.cpu()\\n\\n\\t\\t\\t# A walk around to set optimizing parameters properly\\n\\t\\t\\tresume_optim = self.optimizer.optimizer\\n\\t\\t\\tdefaults = resume_optim.param_groups[0]\\n\\t\\t\\tdefaults.pop('params', None)\\n\\t\\t\\tdefaults.pop('initial_lr', None)\\n\\t\\t\\tself.optimizer.optimizer = resume_optim.__class__(model.parameters(), **defaults)\\n\\n\\t\\t\\tstart_epoch = resume_checkpoint.epoch\\n\\t\\t\\tstep = resume_checkpoint.step\\n\\n\\t\\telse:\\n\\t\\t\\tstart_epoch = 1\\n\\t\\t\\tstep = 0\\n\\n\\t\\t\\tfor name, param in model.named_parameters():\\n\\t\\t\\t\\tlog = self.logger.info('{}:{}'.format(name, param.size()))\\n\\t\\t\\t\\t# check embedder init\\n\\t\\t\\t\\t# if 'embedder' in name:\\n\\t\\t\\t\\t# \\tprint('{}:{}'.format(name, param[5]))\\n\\n\\t\\t\\tif optimizer is None:\\n\\t\\t\\t\\toptimizer = Optimizer(torch.optim.Adam(model.parameters(), \\n\\t\\t\\t\\t\\t\\t\\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\\n\\n\\t\\t\\t\\t# set scheduler\\n\\t\\t\\t\\t# optimizer.set_scheduler(torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer.optimizer, 'min'))\\n\\n\\t\\t\\tself.optimizer = optimizer\\n\\n\\t\\tself.logger.info(\\\"Optimizer: %s, Scheduler: %s\\\" % (self.optimizer.optimizer, self.optimizer.scheduler))\\n\\n\\t\\tself._train_epoches(train_set, model, num_epochs, start_epoch, step, dev_set=dev_set)\\n\\t\\t\\n\\t\\treturn model\",\n \"def train_model(clf, dataloaders, criterion, optimizer, num_epochs=25,\\n patience=10, save_model_path=None, resume=False, finetune=False):\\n\\n since = time.time()\\n\\n val_acc_history = []\\n\\n #best_model_wts = copy.deepcopy(clf.state_dict())\\n best_acc = 0.0\\n best_epoch = 0\\n epoch = 0\\n\\n if resume:\\n assert save_model_path is not None\\n if save_model_path in glob(save_model_path):\\n _model, _criterion, _optimizer, _epoch, _loss, _accuracy, _history = _resume_from_checkpoint(save_model_path)\\n #if finetune:\\n # model.set_requires_grad(_model, True)\\n clf = _model\\n criterion = _criterion\\n optimizer = _optimizer\\n epoch = _epoch + 1\\n best_epoch = _epoch\\n best_acc = _accuracy\\n val_acc_history = _history\\n else:\\n raise Exception(\\\"No such model file in the specified path.\\\")\\n\\n if finetune:\\n model.set_requires_grad(clf, True)\\n\\n best_model_wts = copy.deepcopy(clf.state_dict())\\n test_dataloader = dataloaders.pop('test', None)\\n\\n clf = clf.to(device)\\n\\n for epoch in range(epoch, num_epochs):\\n print('Epoch {}/{}'.format(epoch + 1, num_epochs))\\n print('-' * 10)\\n\\n # Each epoch has a training and validation phase\\n for phase in ['train', 'val']:\\n if phase == 'train':\\n clf.train() # Set model to training mode\\n else:\\n clf.eval() # Set model to evaluate mode\\n\\n running_loss = 0.0\\n running_corrects = 0\\n\\n # Iterate over data.\\n for inputs, labels in tqdm(dataloaders[phase]):\\n inputs = inputs.to(device)\\n labels = labels.to(device).long()\\n\\n # zero the parameter gradients\\n optimizer.zero_grad()\\n\\n # forward\\n # track history if only in train\\n with torch.set_grad_enabled(phase == 'train'):\\n # Get model outputs and calculate loss\\n outputs = clf(inputs)\\n loss = criterion(outputs, labels)\\n\\n _, preds = torch.max(outputs, 1)\\n\\n # backward + optimize only if in training phase\\n if phase == 'train':\\n loss.backward()\\n optimizer.step()\\n\\n # statistics\\n running_loss += loss.item() * inputs.size(0)\\n running_corrects += torch.sum(preds == labels.data)\\n\\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\\n epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)\\n\\n print('{} Loss: {:.4f}, Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\\n\\n # deep copy the model\\n if phase == 'val':\\n val_acc_history.append(epoch_acc)\\n if phase == 'val' and epoch_acc > best_acc:\\n best_acc = epoch_acc\\n best_model_wts = copy.deepcopy(clf.state_dict())\\n best_epoch = epoch\\n if save_model_path:\\n _save_checkpoint(clf, criterion, optimizer, epoch, epoch_loss, best_acc, val_acc_history, save_model_path)\\n print(\\\"Model checkpoint saved successfully in the given path!\\\")\\n print()\\n if patience is not None:\\n if epoch - best_epoch >= patience:\\n break\\n\\n time_elapsed = time.time() - since\\n print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\\n print('Best val Acc: {:4f}'.format(best_acc))\\n\\n # load best model weights\\n clf.load_state_dict(best_model_wts)\\n\\n test_acc = test_model(clf, test_dataloader, criterion, optimizer)\\n if not save_model_path:\\n if IN_COLAB:\\n save_model_path = \\\"/content/drive/My Drive/Audio-classification-using-multiple-attention-mechanism/best_weights.h5\\\"\\n else:\\n save_model_path = \\\"best_weights.h5\\\"\\n save_model(clf, os.path.splitext(save_model_path)[0] + (\\\"_final_finetuned\\\" if finetune else \\\"_final\\\") + os.path.splitext(save_model_path)[1])\\n\\n return clf, val_acc_history, test_acc\",\n \"def train_model():\\n return model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels), shuffle='True')\",\n \"def train_on_whole_data(self):\\n save_model_path = './savedModel/cnn-model'\\n self.build_graph(save_model_path)\\n\\n tf.reset_default_graph()\\n with tf.Session(graph=tf.get_default_graph()) as sess:\\n try:\\n graph = self.__load_graph(sess, save_model_path)\\n self.__train_and_report(sess, graph, range(1, 6), save_model_path)\\n except Exception as e:\\n logger.error(\\\"Something is missing from the previous saved graph, remove it and regenerate graph\\\")\\n shutil.rmtree(\\\"./savedModel\\\")\\n exit()\",\n \"def train_model(dataset):\\n\\n # clear the session so that we can train more than one model\\n K.clear_session()\\n\\n # initialize the model\\n model = initalizer.init_nn()\\n\\n # fit the model\\n model.fit(dataset, epochs=40)\\n\\n return model\",\n \"def train(self, trainfile):\",\n \"def save_model(self, path):\\n try:\\n # os.makedirs(osp.dirname(path), exist_ok=1)\\n joblib.dump(self.model, path)\\n except Exception as e:\\n print(e)\\n print(\\\"Couldn't save scikit learn model on path {}!\\\".format(path))\",\n \"def train():\\n pass\",\n \"def train(data_dir, epochs, batch_size, lr, optimizer, categories):\\n run = Run.get_context()\\n\\n run.log('optimizer', optimizer)\\n run.log('minibatch_size', batch_size)\\n run.log('learning_rate', lr)\\n run.log('categories', categories)\\n\\n # Get model and data objects\\n train_generator, validation_generator = create_dataset_generators(\\n data_dir, batch_size, categories\\n )\\n \\n model = create_model(lr=lr, classes=train_generator.num_classes, optimizer_name=optimizer)\\n print(model.optimizer)\\n \\n os.makedirs(\\\"./outputs\\\", exist_ok=True)\\n\\n with open('./outputs/labels.json', 'w') as fo:\\n json.dump(train_generator.class_indices, fo)\\n\\n aml_callback = AzureMLCallback(run)\\n checkpointer = ModelCheckpoint(\\n filepath=\\\"./outputs/weights_{epoch:02d}.hdf5\\\", period=25)\\n\\n history = model.fit_generator(\\n train_generator,\\n steps_per_epoch=train_generator.samples / batch_size,\\n epochs=epochs,\\n validation_data=validation_generator,\\n validation_steps=validation_generator.samples / batch_size,\\n verbose=2,\\n callbacks=[aml_callback, checkpointer],\\n )\\n\\n model.save(\\\"./outputs/final_model.hdf5\\\")\",\n \"def train_test_model_batch():\\n train=learning.Train_kmer_clf()\\n train.run()\",\n \"def trainModel(model, train_raw, validation_raw):\\n # compile and train the model using the generator function\\n train_generator = generator(train_raw, batch_size=32)\\n validation_generator = generator(validation_raw, batch_size=32)\\n\\n # model checkpoint\\n now = datetime.datetime.now()\\n datenow = now.strftime(\\\"%Y-%m-%d-\\\")\\n #file_path_model = \\\"Model_checkpoints/\\\" + datenow + \\\"model-weights-{epoch:02d}-{val_loss:0.2f}.hdf5\\\"\\n file_path_model = \\\"Model_checkpoints/\\\" + datenow + \\\"model-weights.hdf5\\\"\\n checkpoint = ModelCheckpoint(file_path_model, monitor='val_loss', verbose=1, save_best_only=True, mode='auto')\\n callbacks_list = [checkpoint]\\n model.compile(loss='mse', optimizer='adam')\\n # left/center/right images, and all flipped\\n ntrain = len(train_raw)*3*2\\n nvalid = len(validation_raw)*3*2\\n history_object = model.fit_generator(train_generator, samples_per_epoch= \\\\\\n ntrain, validation_data=validation_generator, \\\\\\n nb_val_samples=nvalid, nb_epoch=10, \\\\\\n callbacks = callbacks_list, verbose=1)\\n #history_object = model.fit_generator(train_generator, steps_per_epoch= ntrain, \\\\\\n # validation_data=validation_generator, validation_steps=nvalid, \\\\\\n # callbacks = callbacks_list, epochs=5, verbose = 1) \\n return history_object\",\n \"def save_model(model):\\n model.to_disk(\\\"../model/custom_ner_model\\\")\",\n \"def train_teacher (nb_teachers, teacher_id):\\n # Load the dataset\\n X_train, X_test, y_train, y_test = models.get_dataset()\\n\\n print(X_train.shape)\\n print(y_train.shape)\\n print(X_test.shape)\\n print(y_test.shape)\\n \\n # Retrieve subset of data for this teacher\\n data, labels = partition.partition_dataset(X_train,\\n y_train,\\n nb_teachers,\\n teacher_id)\\n\\n print(\\\"Length of training data: \\\" + str(len(labels)))\\n\\n # Define teacher checkpoint filename and full path\\n\\n filename = str(nb_teachers) + '_teachers_' + str(teacher_id) + '.hdf5'\\n filename2 = str(nb_teachers) + '_teachers_' + str(teacher_id) + '.h5'\\n \\n # Perform teacher training need to modify \\n \\n\\n # Create teacher model\\n model, opt = models.create_two_layer_mlp(46) # num of cols\\n model.compile(loss='binary_crossentropy',\\n optimizer=\\\"Adam\\\",\\n metrics=['accuracy'])\\n model, hist = models.training(model, data, X_test, labels, y_test,filename)\\n\\n #modify\\n model_json = model.to_json()\\n with open(\\\"model.json\\\", \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n# serialize weights to HDF5\\n model.save_weights(filename2)\\n print(\\\"Saved model to disk\\\")\\n return True\",\n \"def train(self, X_train, y_train):\\n\\n self.model_pipeline.fit(X_train, y_train)\",\n \"def train_model():\\n if (not request.json \\n or not 'data-format' in request.json\\n or not 'ML-model' in request.json\\n or not 'source-data-directory' in request.json\\n or not 'source-data-repo' in request.json):\\n abort(400)\\n\\n data_format = request.json['data-format']\\n ML_model = request.json['ML-model']\\n source_data_directory = request.json['source-data-directory']\\n source_data_repo = request.json['source-data-repo']\\n \\n start = time.time()\\n\\n do_train(model_name=ML_model, \\n repo_url=source_data_repo, \\n repo_data_directory=source_data_directory, \\n data_format=data_format)\\n \\n end = time.time()\\n\\n runningtime = (end - start)\\n\\n return f'Model {ML_model} trained using source data in directory {source_data_directory}, running time {runningtime} seconds', 201\",\n \"def setup_training(model, train_loader, valid_loader, hps):\\r\\n\\r\\n train_dir = os.path.join(hps.save_root, \\\"train\\\")\\r\\n if not os.path.exists(train_dir): os.makedirs(train_dir)\\r\\n\\r\\n if hps.restore_model != 'None':\\r\\n logger.info(\\\"[INFO] Restoring %s for training...\\\", hps.restore_model)\\r\\n bestmodel_file = os.path.join(train_dir, hps.restore_model)\\r\\n loader = ModelLoader()\\r\\n loader.load_pytorch(model, bestmodel_file)\\r\\n else:\\r\\n logger.info(\\\"[INFO] Create new model for training...\\\")\\r\\n\\r\\n run_training(model, train_loader, valid_loader, hps) # this is an infinite loop until interrupted\\r\",\n \"def train_model(model, X_train, X_valid, Y_train, Y_valid):\\n\\n # Let's CreateCheckPoint so as to save our best models and model Logs after every epoch.\\n # This checkPoint function will be called as callback functions after every epoch.\\n\\n checkpoint = ModelCheckpoint(\\n 'model-{epoch:03d}.h5', monitor='val_loss', verbose=0, save_best_only=True, mode='auto')\\n\\n tensorboard = TensorBoard(log_dir=\\\"log\\\\{}\\\".format(time())) \\n\\n model.compile(loss='mean_squared_error', optimizer=Adam(lr=LEARNING_RATE))\\n\\n model.fit_generator(batch_generator(DATA_DIR, X_train, Y_train, BATCH_SIZE, True),\\n SAMPLES_PER_EPOCH,\\n NO_OF_EPOCHS,\\n max_q_size=1,\\n validation_data=batch_generator(\\n DATA_DIR, X_valid, Y_valid, BATCH_SIZE, False),\\n nb_val_samples=len(X_valid),\\n callbacks=[checkpoint, tensorboard],\\n verbose=1\\n )\",\n \"def save_model(self):\\n self.pred_net.save((self.save_path / \\\"iqn_pred_net\\\").absolute().as_posix())\\n self.target_net.save((self.save_path / \\\"iqn_target_net\\\").absolute().as_posix())\",\n \"def train_model(model, dataset, validation_set, epochs, label_name,\\n batch_size=None):\\n\\n # Split the training set into features and label.\\n features = {name:np.array(value) for name, value in dataset.items()}\\n label = np.array(features.pop(label_name))\\n \\n # Split the validation set into features and label.\\n val_features = {name:np.array(value) for name, value in validation_set.items()}\\n val_label = np.array(val_features.pop(label_name))\\n \\n history = model.fit(x=features, y=label, batch_size=batch_size,\\n epochs=epochs, shuffle=True, validation_data=(val_features, val_label)) \\n\\n # The list of epochs is stored separately from the rest of history.\\n epochs = history.epoch\\n \\n # To track the progression of training, gather a snapshot\\n # of the model's mean squared error at each epoch. \\n hist = pd.DataFrame(history.history)\\n rmse = hist[\\\"root_mean_squared_error\\\"]\\n\\n return epochs, rmse, hist\",\n \"def start_training(self):\\n i = 0\\n for _ in range(self.train_steps):\\n print(f\\\"Start Training Step {i + 1}\\\")\\n self.model.learn(total_timesteps=self.total_time_steps)\\n self.model.save(self.save_path)\\n print(f\\\"Finished Training Step {i + 1}\\\")\\n i += 1\",\n \"def train_and_eval(model_dir, model_type, train_steps, train_data, test_data, train_embeddings_file_name, test_embeddings_file_name, positive_labels, combination_method, method):\\n \\n index_map, weights = wvd.load(train_embeddings_file_name)\\n #Get positive labels\\n positive_labels = positive_labels.split(',')\\n \\n print(\\\"reading data...\\\")\\n train_file_name = train_data \\n df_train = pd.read_table(train_file_name, dtype={'node1':str, 'node2':str})\\n df_train = df_train.sample(frac=1)\\n\\n # remove NaN elements\\n df_train = df_train.dropna(how='any', axis=0)\\n \\n df_train[LABEL_COLUMN] = (\\n df_train[\\\"label\\\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\\n\\n model_dir = tempfile.mkdtemp() if not model_dir else model_dir\\n print(\\\"model directory = %s\\\" % model_dir)\\n \\n train_x, _, train_y, _ = get_input(df_train, weights, index_map, combination_method)\\n \\n print(\\\"\\\\nBuilding model...\\\")\\n m = build_estimator(model_dir, model_type, weights, index_map, combination_method)\\n \\n print(\\\"\\\\nTraining model...\\\")\\n if model_type == \\\"regressor\\\":\\n m.fit(train_x, train_y, n_epoch=train_steps, show_metric=True, snapshot_epoch=False)\\n \\n print(\\\"\\\\nTesting model...\\\")\\n index_map, weights = wvd.load(test_embeddings_file_name)\\n \\n print(\\\"reading data...\\\")\\n test_file_name = test_data\\n df_test = pd.read_table(test_file_name, dtype={'node1':str, 'node2':str})\\n df_test = df_test.sample(frac=1)\\n\\n # remove NaN elements\\n df_test = df_test.dropna(how='any', axis=0)\\n \\n df_test[LABEL_COLUMN] = (\\n df_test[\\\"label\\\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\\n \\n if model_type == \\\"regressor\\\":\\n test_x, test_original_y, test_index_y, test_original_x = get_input(df_test, weights, index_map, combination_method, data_purpose='test')\\n node_sets = get_node_sets(test_original_x, test_original_y)\\n \\n print(\\\"\\\\nPredicting:\\\")\\n model_predictions = m.predict(test_x)\\n model_predictions = list(model_predictions)\\n #Covert back to 1 and 0\\n predictions = []\\n model_predictions_probs = []\\n for prediction in model_predictions:\\n predictions.append(prediction[1]) #non-thresholded value of positve class\\n model_predictions_probs.append(prediction[1])\\n \\n k = int(len([i for i in test_original_y if i == 1]) * 0.3)\\n do_evaluations([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \\n positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method)\\n #Uncomment to log ranked links\\n #log_predictions([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \\n # positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method,\\n # outfilename=combination_method, method=method)\",\n \"def train(self, dataset, k=20, n_epochs=10, save_dir='./models', save=True, model_name='GRU4REC'):\\n print(f'Training {model_name}...')\\n\\n for epoch in range(n_epochs):\\n results = self.run_epoch(dataset, k=k, training=True)\\n results = [f'{k}:{v:.3f}' for k, v in results.items()]\\n print(f'epoch:{epoch+1:2d}/{\\\"/\\\".join(results)}')\\n \\n # Store the intermediate model\\n if save:\\n save_dir = Path(save_dir)\\n if not save_dir.exists(): save_dir.mkdir()\\n model_fname = f'{model_name}_{self.loss_type}_{self.optimizer_type}_{self.lr}_epoch{epoch+1:d}'\\n torch.save(self.gru.state_dict(), save_dir/model_fname)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7705048","0.74385786","0.7426859","0.7407801","0.7267371","0.7208689","0.71939373","0.71755517","0.71754044","0.7151909","0.7151358","0.7147768","0.7145118","0.7128991","0.71117663","0.7085029","0.7073787","0.7053388","0.70399153","0.70298266","0.702379","0.7020547","0.7000431","0.69963115","0.69957876","0.6975565","0.69719315","0.692459","0.6905385","0.68885994","0.68865496","0.6881413","0.68598706","0.6840358","0.6837278","0.6833031","0.68308747","0.67920214","0.67840433","0.677422","0.6760922","0.6751502","0.67489666","0.6743778","0.67423356","0.67336494","0.6728917","0.6725941","0.67234224","0.67076045","0.67050743","0.6691931","0.66871285","0.6676595","0.6676402","0.667454","0.66725355","0.66650546","0.66611016","0.66486365","0.6648079","0.6646048","0.6639478","0.6639115","0.66315794","0.66142654","0.6609703","0.6609204","0.66041833","0.65919757","0.65910083","0.6590335","0.6578667","0.65765846","0.65764374","0.65759283","0.65742743","0.65733427","0.65660536","0.6563976","0.6560233","0.6556987","0.65524936","0.6552144","0.65453595","0.65434384","0.6540877","0.6537877","0.6532175","0.65266305","0.6524525","0.6523608","0.65229046","0.65190005","0.6514093","0.6510024","0.65053195","0.65003926","0.6494326","0.6485995"],"string":"[\n \"0.7705048\",\n \"0.74385786\",\n \"0.7426859\",\n \"0.7407801\",\n \"0.7267371\",\n \"0.7208689\",\n \"0.71939373\",\n \"0.71755517\",\n \"0.71754044\",\n \"0.7151909\",\n \"0.7151358\",\n \"0.7147768\",\n \"0.7145118\",\n \"0.7128991\",\n \"0.71117663\",\n \"0.7085029\",\n \"0.7073787\",\n \"0.7053388\",\n \"0.70399153\",\n \"0.70298266\",\n \"0.702379\",\n \"0.7020547\",\n \"0.7000431\",\n \"0.69963115\",\n \"0.69957876\",\n \"0.6975565\",\n \"0.69719315\",\n \"0.692459\",\n \"0.6905385\",\n \"0.68885994\",\n \"0.68865496\",\n \"0.6881413\",\n \"0.68598706\",\n \"0.6840358\",\n \"0.6837278\",\n \"0.6833031\",\n \"0.68308747\",\n \"0.67920214\",\n \"0.67840433\",\n \"0.677422\",\n \"0.6760922\",\n \"0.6751502\",\n \"0.67489666\",\n \"0.6743778\",\n \"0.67423356\",\n \"0.67336494\",\n \"0.6728917\",\n \"0.6725941\",\n \"0.67234224\",\n \"0.67076045\",\n \"0.67050743\",\n \"0.6691931\",\n \"0.66871285\",\n \"0.6676595\",\n \"0.6676402\",\n \"0.667454\",\n \"0.66725355\",\n \"0.66650546\",\n \"0.66611016\",\n \"0.66486365\",\n \"0.6648079\",\n \"0.6646048\",\n \"0.6639478\",\n \"0.6639115\",\n \"0.66315794\",\n \"0.66142654\",\n \"0.6609703\",\n \"0.6609204\",\n \"0.66041833\",\n \"0.65919757\",\n \"0.65910083\",\n \"0.6590335\",\n \"0.6578667\",\n \"0.65765846\",\n \"0.65764374\",\n \"0.65759283\",\n \"0.65742743\",\n \"0.65733427\",\n \"0.65660536\",\n \"0.6563976\",\n \"0.6560233\",\n \"0.6556987\",\n \"0.65524936\",\n \"0.6552144\",\n \"0.65453595\",\n \"0.65434384\",\n \"0.6540877\",\n \"0.6537877\",\n \"0.6532175\",\n \"0.65266305\",\n \"0.6524525\",\n \"0.6523608\",\n \"0.65229046\",\n \"0.65190005\",\n \"0.6514093\",\n \"0.6510024\",\n \"0.65053195\",\n \"0.65003926\",\n \"0.6494326\",\n \"0.6485995\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7325195"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":4196,"cells":{"query":{"kind":"string","value":"Base class for Python RL environments."},"document":{"kind":"string","value":"def __init__(self, handle_auto_reset: bool = False):\n self._handle_auto_reset = handle_auto_reset\n self._current_time_step = None\n common.assert_members_are_not_overridden(\n base_cls=PyEnvironment, instance=self, denylist=('reset', 'step')\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self): \n\t\n\t # get the environment\n\t\tself.env = env()","def __init__(self, env):\n gym.Wrapper.__init__(self, env)","def __init__(self, env):\n gym.Wrapper.__init__(self, env)","def __init__(self, env):\n super().__init__(env)","def __init__(self, env):\n super().__init__(env)","def __init__(self, env):\n super().__init__(env)","def _run_env(self):\n raise NotImplementedError()","def __init__(self, env):\n gym.RewardWrapper.__init__(self, env)","def __init__(self, env, system=None):\n self._env = env\n self._system = system if system is not None else {}","def running_environment(self) -> type:\n return OrdinaryMNLBandit","def get_environment():\n return GenericGymEnv(id=\"real-time-gym-v1\", gym_kwargs={\"config\": CONFIG_DICT})","def __init__(self, env):\r\n gym.Wrapper.__init__(self, env)\r\n self.lives = 0\r\n self.was_real_done = True","def __init__( self ):\n self._env = None\n self._steps = None\n\n self._initialize( )","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n self.lives = 0\n self.was_real_done = True","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n self.lives = 0\n self.was_real_done = True","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n self.lives = 0\n self.was_real_done = True","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n self.lives = 0\n self.was_real_done = True","def __init__(self, printer):\n super(BashParentEnvironment, self).__init__()\n self._printer = printer","def __init__(self, template_env):\r\n self._template_env = template_env\r\n self._pythons = []","def __init__(self, \n ns: str, \n reward_fnc: str, \n is_action_space_discrete, \n safe_dist: float = None, \n goal_radius: float = 0.1, \n max_steps_per_episode=100, \n train_mode: bool = True, \n debug: bool = False,\n task_mode: str = \"staged\",\n PATHS: dict = dict(),\n extended_eval: bool = False,\n *args, **kwargs):\n super(FlatlandEnv, self).__init__()\n\n self.ns = ns\n try:\n # given every environment enough time to initialize, if we dont put sleep,\n # the training script may crash.\n ns_int = int(ns.split(\"_\")[1])\n time.sleep(ns_int*2)\n except Exception:\n rospy.logwarn(f\"Can't not determinate the number of the environment, training script may crash!\")\n pass\n\n\n # process specific namespace in ros system\n self.ns_prefix = '' if (ns == '' or ns is None) else '/'+ns+'/'\n \n if not debug:\n if train_mode:\n rospy.init_node(f'train_env_{self.ns}', disable_signals=False)\n else:\n rospy.init_node(f'eval_env_{self.ns}', disable_signals=False)\n\n self._extended_eval = extended_eval\n self._is_train_mode = rospy.get_param(\"/train_mode\")\n self._is_action_space_discrete = is_action_space_discrete\n \n self.setup_by_configuration(PATHS['robot_setting'], PATHS['robot_as'])\n\n # set rosparam\n rospy.set_param(\"/laser_num_beams\", self._laser_num_beams)\n \n # observation collector\n self.observation_collector = ObservationCollector(\n self.ns, self._laser_num_beams, self._laser_max_range)\n self.observation_space = self.observation_collector.get_observation_space()\n\n # reward calculator\n if safe_dist is None:\n safe_dist = 1.6*self._robot_radius\n\n self.reward_calculator = RewardCalculator(\n robot_radius=self._robot_radius, safe_dist=1.6*self._robot_radius, goal_radius=goal_radius, \n rule=reward_fnc, extended_eval=self._extended_eval)\n\n # action agent publisher\n if self._is_train_mode:\n self.agent_action_pub = rospy.Publisher(f'{self.ns_prefix}cmd_vel', Twist, queue_size=1)\n else:\n self.agent_action_pub = rospy.Publisher(f'{self.ns_prefix}cmd_vel_pub', Twist, queue_size=1)\n\n # service clients\n if self._is_train_mode:\n self._service_name_step = f'{self.ns_prefix}step_world'\n self._sim_step_client = rospy.ServiceProxy(\n self._service_name_step, StepWorld)\n \n # instantiate task manager\n self.task = get_predefined_task(\n ns, mode=task_mode, start_stage=kwargs['curr_stage'], PATHS=PATHS)\n\n self._steps_curr_episode = 0\n self._max_steps_per_episode = max_steps_per_episode\n\n # for extended eval\n self._action_frequency = 1/rospy.get_param(\"/robot_action_rate\")\n self._last_robot_pose = None\n self._distance_travelled = 0\n self._safe_dist_counter = 0\n self._collisions = 0\n self._in_crash = False","def base_env(*args, **kwargs):\n try:\n # regular gym\n env = gym.make(*args, **kwargs)\n except:\n try:\n # gym retro\n env = retro.make(*args, **kwargs)\n except:\n # gym-super-mario-bros\n env = gym_super_mario_bros.make(*args, **kwargs)\n env.recognized = None\n return env","def __init__(self, printer):\n super(PowershellParentEnvironment, self).__init__()\n self._printer = printer","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n # 1st, we will have 2 attributes: self.lives and self.was_real_done\n self.lives = 0\n self.was_real_done = True","def init():\n env = Environment(5, 5, 20, [10, 20, 10, 5])\n return env","def standard_env():\n \"\"\"An environment with some Scheme standard procedures.\"\"\"\n env = Env()\n env.update(\n {\n \"+\": op.add,\n \"-\": op.sub,\n \"*\": op.mul,\n \"/\": op.truediv,\n \"car\": lambda x: x[0],\n \"cdr\": lambda x: x[1:] if len(x) > 2 else x[1],\n \"cons\": lambda x, y: [x] + y if isinstance(y, list) else [x, y],\n \"eq?\": op.eq,\n \"atom?\": lambda x: type(x) in AtomicTypes,\n }\n )\n return env","def initialise(self, args, environ):","def __init__(self, env):\n\n self.env = env\n self.env_info = env.env_info\n\n self.best_policy = None\n self.best_score = 0\n\n # Time to run the environment for during training and evaluation\n self.max_t = MAX_T\n # Maximum possible reward given the environment\n if (self.env.max_reward_per_timestep is None\n and self.env.max_reward_per_episode is None):\n raise ValueError(\"Either max_reward_per_timestep or \"\n \"max_reward_per_episode needs to be set.\")\n elif (self.env.max_reward_per_timestep is None\n and self.env.max_reward_per_episode is None):\n raise ValueError(\"Either max_reward_per_timestep or \"\n \"max_reward_per_episode needs to be None.\")\n elif self.env.max_reward_per_timestep is not None:\n self.max_reward = self.env.max_reward_per_timestep * self.max_t\n else:\n self.max_reward = self.env.max_reward_per_episode","def __init__(self,\n env_name='blobble-world-v0'\n ):\n self._env_name = env_name\n\n # Take a timestamp. This will be used for any output files created in the output folder\n self._timestamp = datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M\")\n\n # Create training and evaluation environments\n self._train_py_env = suite_gym.load(self._env_name)\n self._eval_py_env = suite_gym.load(self._env_name)\n\n # Convert the training and test environments to Tensors\n self._train_env = tf_py_environment.TFPyEnvironment(self._train_py_env)\n self._eval_env = tf_py_environment.TFPyEnvironment(self._eval_py_env)\n print('=====================================================')\n print('Environments created for : ', self._env_name)\n print('Training Environment')\n print(' Observation Spec:')\n print(' ', self._train_env.time_step_spec().observation)\n print(' Reward Spec:')\n print(' ', self._train_env.time_step_spec().reward)\n print(' Action Spec:')\n print(' ', self._train_env.action_spec())\n print('Evaluation Environment')\n print(' Observation Spec:')\n print(' ', self._eval_env.time_step_spec().observation)\n print(' Reward Spec:')\n print(' ', self._eval_env.time_step_spec().reward)\n print(' Action Spec:')\n print(' ', self._eval_env.action_spec())\n print('=====================================================')\n\n self._config = BlobbleConfig('blobble_config.ini')\n self._config.print_config()\n\n # Get the demonstration parameters and output folder. We don't need these just yet but it's\n # good to do now in case there is an error in the config file (exception will be thrown)\n self._output_folder = (self._config.get_output_params()['output_folder'])\n\n self._num_demo_episodes = int(self._config.get_output_params()['num_demonstration_episodes'])\n demo_video = (self._config.get_output_params()['demonstration_video'])\n if demo_video == 'True':\n self._demo_video = True\n else:\n self._demo_video = False\n\n # Get and check the advanced learning parameters\n self._learning_rate = float(self._config.get_learning_adv_params()['learning_rate'])\n self._fc_layer_params = tuple(self._config.get_learning_adv_params()['fc_layer_params'].split(','))\n\n print('Create and train a neural network agent')\n self._neural_network_agent = create_neural_network_agent(self._train_env,\n self._learning_rate,\n self._fc_layer_params)\n\n learning_params = self._config.get_learning_params()\n train_neural_network(self._neural_network_agent,\n self._train_env,\n self._eval_env,\n num_train_iterations=learning_params['training_iterations'],\n log_interval=learning_params['training_log_interval'],\n eval_interval=learning_params['eval_interval'],\n num_eval_episodes=learning_params['num_eval_episodes'],\n replay_buffer_max_length=learning_params['replay_buffer_max_length'],\n collect_steps_per_iteration=learning_params['collect_steps_per_iteration'],\n output_folder=self._output_folder,\n timestamp=self._timestamp)","def env(self) -> Optional[Env]:\n raise NotImplementedError","def _get_environment(cls):\n return cls.__name__.lower()","def SetupEnvironment(self):\n pass","def getEnvironment(self):\n pass","def __init__(self, *args):\n self.env = os.environ.copy()\n \"\"\"Environment variables (:class:`dict`)\"\"\"\n command = \"modulecmd python \"+' '.join(args)\n p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)\n retval = p.communicate()\n self._parse(retval)","def step_env(self):\n raise NotImplementedError\n # Not needed for this homework","def __init__(self, max_step=-1):\n self.environment = mls.rl.common.Environment()\n self.environment.game = mls.rl.common.Game(max_step=max_step)\n self.environment.current_state = self.environment.game.init_state(self.environment)","def __init__(__self__,\n resource_name: str,\n args: EnvironmentArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def __init__(self):\n self._opts = {} # dict of dicts of (opt:, override:, default:)\n self._groups = {}\n self._deprecated_opts = {}\n\n self._args = None\n\n self._oparser = None\n self._namespace = None\n self._mutable_ns = None\n self._mutate_hooks = set([])\n self.__cache = {}\n self.__drivers_cache = {}\n self._config_opts = []\n self._cli_opts = collections.deque()\n self._validate_default_values = False\n self._sources = []\n self._ext_mgr = None\n # Though the env_driver is a Source, we load it by default.\n self._use_env = True\n self._env_driver = _environment.EnvironmentConfigurationSource()\n\n self.register_opt(self._config_source_opt)","def __init__(self, model: WorldModel, real_env: ModelBasedEnv):\n super(VirtualEnv, self).__init__()\n self.action_space = real_env.action_space\n self.observation_space = real_env.observation_space\n self.reward_range = real_env.reward_range\n self.cost_fn = real_env.cost_fn\n self.model = model\n self.current_state = None\n\n self.initial_states_pool = None\n\n if real_env.spec is not None and hasattr(real_env.spec, 'max_episode_steps'):\n self.max_episode_steps = real_env.spec.max_episode_steps\n else:\n self.max_episode_steps = float('inf')","def __MakeEnvironment(self):\n environment= os.environ.copy()\n\n for key, value in self.__context.items():\n if type(value) is str:\n name = \"QMV_\" + key.replace(\".\", \"__\")\n environment[name]= value\n\n return environment","def __init__(self):\n # Select all the environment variables starting with 'ASH_CFG_' and strip\n # off the leading ASH_CFG_ portion to use as the name of the variable.\n self.variables = dict(\n [(x[8:], y) for x, y in os.environ.items() if x.startswith('ASH_CFG_')]\n )","def __init__(self, env, noop_max=30):\n gym.Wrapper.__init__(self, env)\n self.noop_max = noop_max\n self.override_num_noops = None\n self.noop_action = 0","def __init__(self, environment_variables=None, var_prefix='PLATFORM_'):\n\n self._environmentVariables = os.environ if environment_variables is None else environment_variables\n self._varPrefix = var_prefix\n\n if self['ROUTES']:\n routes = self['ROUTES']\n self._routesDef = self.decode(routes)\n if self['RELATIONSHIPS']:\n relationships = self['RELATIONSHIPS']\n self._relationshipsDef = self.decode(relationships)\n self.register_formatter('pymongo', pymongo_formatter)\n self.register_formatter('pysolr', pysolr_formatter)\n self.register_formatter('postgresql_dsn', posgresql_dsn_formatter)\n\n if self['VARIABLES']:\n variables = self['VARIABLES']\n self._variablesDef = self.decode(variables)\n if self['APPLICATION']:\n application = self['APPLICATION']\n self._applicationDef = self.decode(application)","def __init__(self, step_runner, properties, environ, universe_view,\n engine_flags=None):\n self._step_runner = step_runner\n self._properties = properties\n self._environ = environ.copy()\n self._universe_view = universe_view\n self._clients = {client.IDENT: client for client in (\n recipe_api.DependencyManagerClient(self),\n recipe_api.PathsClient(),\n recipe_api.PropertiesClient(self),\n recipe_api.SourceManifestClient(self, properties),\n recipe_api.StepClient(self),\n )}\n self._engine_flags = engine_flags\n\n # A stack of ActiveStep objects, holding the most recently executed step at\n # each nest level (objects deeper in the stack have lower nest levels).\n # When we pop from this stack, we close the corresponding step stream.\n self._step_stack = []","def __attrs_post_init__(self):\n self.path = (Path(CONFIG['conda_folder']) / 'envs' / self.name)","def initialize():\n environment = Environment()\n environment.setup()","def __init__(self, name=None):\n super(TTSEngine, self).__init__()","def __init__(__self__, *,\n application_name: pulumi.Input[str],\n cname_prefix: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n environment_name: Optional[pulumi.Input[str]] = None,\n operations_role: Optional[pulumi.Input[str]] = None,\n option_settings: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentOptionSettingArgs']]]] = None,\n platform_arn: Optional[pulumi.Input[str]] = None,\n solution_stack_name: Optional[pulumi.Input[str]] = None,\n tags: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentTagArgs']]]] = None,\n template_name: Optional[pulumi.Input[str]] = None,\n tier: Optional[pulumi.Input['EnvironmentTierArgs']] = None,\n version_label: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"application_name\", application_name)\n if cname_prefix is not None:\n pulumi.set(__self__, \"cname_prefix\", cname_prefix)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if environment_name is not None:\n pulumi.set(__self__, \"environment_name\", environment_name)\n if operations_role is not None:\n pulumi.set(__self__, \"operations_role\", operations_role)\n if option_settings is not None:\n pulumi.set(__self__, \"option_settings\", option_settings)\n if platform_arn is not None:\n pulumi.set(__self__, \"platform_arn\", platform_arn)\n if solution_stack_name is not None:\n pulumi.set(__self__, \"solution_stack_name\", solution_stack_name)\n if tags is not None:\n pulumi.set(__self__, \"tags\", tags)\n if template_name is not None:\n pulumi.set(__self__, \"template_name\", template_name)\n if tier is not None:\n pulumi.set(__self__, \"tier\", tier)\n if version_label is not None:\n pulumi.set(__self__, \"version_label\", version_label)","def make_problem_service(config: ProblemServiceConfig):\n\n class ProblemService(rpyc.Service):\n \"\"\"Spools up a new Python interpreter and uses it to sandbox SSiPP and\n MDPSim. Can interact with this to train a Q-network.\"\"\"\n\n # TODO: figure out some way of ensuring that arguments and return\n # values are deep-copied, or the whole impl will end up dog slow.\n\n def exposed_extend_replay(self, get_action, n_paths):\n \"\"\"Extend the replay buffer using the given policy (represented as a\n function from flattened observation vectors to action numbenrs).\"\"\"\n n_paths = to_local(n_paths)\n return self.internal_extend_replay(get_action, n_paths)\n\n def exposed_batch_iter(self, batch_size, n_batches):\n \"\"\"Sample <batch_size> elements from internal buffer.\"\"\"\n batch_size = to_local(batch_size)\n n_batches = to_local(n_batches)\n # first convert replay buffer to a list so that we can shuffle and\n # take indices\n assert len(self.replay) > 0, 'need non-empty replay pool'\n ordered_buf = list(self.replay)\n shuffle(ordered_buf) # in-place\n gen = cycle(ordered_buf)\n for batch_num in range(n_batches):\n rich_batch = list(islice(gen, batch_size))\n yield self.flatten_batch(rich_batch)\n\n def exposed_env_reset(self):\n return self.env_wrapped.reset()\n\n def exposed_action_name(self, action_num):\n action_num = to_local(action_num)\n return self.env_raw.action_name(action_num)\n\n def exposed_env_step(self, action):\n action = to_local(action)\n return self.env_wrapped.step(action)\n\n # note to self: RPyC doesn't support @property\n\n def exposed_get_ssipp_dead_end_value(self):\n return self.p.ssipp_dead_end_value\n\n def exposed_get_meta(self):\n \"\"\"Get name, ProblemMeta and DomainMeta for the current problem.\"\"\"\n return self.problem_meta, self.domain_meta\n\n def exposed_get_replay_size(self):\n return len(self.replay)\n\n def exposed_get_env_spec(self):\n # this will have to be deep-copied to actually work (I think)\n return self.env_wrapped.spec\n\n def exposed_get_obs_dim(self):\n return self.env_wrapped.observation_space.flat_dim\n\n def exposed_get_act_dim(self):\n return self.env_wrapped.action_space.flat_dim\n\n def exposed_get_obs_dtype_name(self):\n return self.env_wrapped.observation_space.dtype.name\n\n def exposed_get_dg_extra_dim(self):\n data_gens = self.env_raw.data_gens\n return sum([g.extra_dim for g in data_gens])\n\n def exposed_get_max_len(self):\n return self.max_len\n\n def exposed_get_problem_names(self):\n # fetch a list of all problems loaded by MDPSim\n return sorted(self.p.mdpsim.get_problems().keys())\n\n def exposed_get_current_problem_name(self):\n return self.p.problem_name\n\n def on_connect(self):\n self.p = PlannerExtensions(config.pddl_files,\n config.init_problem_name)\n mdpsim_p = self.p.mdpsim_problem\n self.domain_meta = get_domain_meta(mdpsim_p.domain)\n self.problem_meta = get_problem_meta(mdpsim_p, self.domain_meta)\n self.env_raw, self.env_wrapped = create_environment(\n problem_meta=self.problem_meta,\n planner_extensions=self.p,\n heuristic_name=config.heuristic_name,\n use_lm_cuts=config.use_lm_cuts,\n dump_table_path=config.dump_table_path,\n dump_table_interval=config.dump_table_interval)\n self.planner = Planner(self.p, 'lrtdp', config.teacher_heur)\n\n # maximum length of a trace to gather\n self.max_len = config.max_len\n # will hold (state, action) pairs to train on\n self.replay = set() # type: Set[StateQVs]\n\n @lru_cache(None)\n def opt_pol_envelope(self, obs: FPGObservation) -> List[StateQVs]:\n \"\"\"Get (s, a) pairs for optimal policy from given state.\"\"\"\n return planner_trace(self.planner, self.problem_meta,\n self.p.mdpsim_problem, obs)\n\n def internal_extend_replay(self, get_action: Any, n_paths: int) \\\n -> float:\n \"\"\"Extend the supervision buffer with some new paths. Can probably make\n this more sophisticated by turning it into a least-recently-visited\n cache or something.\"\"\"\n paths, succ_rate = collect_paths(\n rllab_env=self.env_wrapped,\n prob_meta=self.problem_meta,\n get_action=get_action,\n n_paths=n_paths,\n max_len=self.max_len)\n new_pairs = set()\n for path in paths:\n # ignore original action\n for obs, _ in path:\n # I used to hard negative mine (only add to training set if\n # net gets it wrong), but now I don't bother\n new_pairs.update(self.opt_pol_envelope(obs))\n self.replay.update(new_pairs)\n return succ_rate\n\n def flatten_batch(self, rich_batch: List[StateQVs]) \\\n -> Tuple[np.ndarray, np.ndarray]:\n rich_obs, rich_qvs = zip(*rich_batch)\n obs_tensor = self.env_raw.observation_space.flatten_n(rich_obs)\n qv_lists = []\n for qv_pairs in rich_qvs:\n qv_dict = dict(qv_pairs)\n qv_list = [\n qv_dict[ba] for ba in self.problem_meta.bound_acts_ordered\n ]\n qv_lists.append(qv_list)\n qv_tensor = np.array(qv_lists)\n return obs_tensor, qv_tensor\n\n return ProblemService","def set_pyenv_cfg(self): # noqa: D205\n super().set_pyenv_cfg()\n self.pyenv_cfg[\"base-prefix\"] = self.interpreter.system_prefix\n self.pyenv_cfg[\"base-exec-prefix\"] = self.interpreter.system_exec_prefix\n self.pyenv_cfg[\"base-executable\"] = self.interpreter.system_executable","def cli(self, env):\n raise NotImplementedError","def __init__(self):\n # The current information for the environment\n self.state_space = ()\n self.action_space = ()\n self.state = None\n self.reward = 0\n self.terminal = False\n self.truncated = False\n self.info = None","def make_env():\n return {\n 'init': init,\n 'step': step,\n 'is_terminal': is_terminal,\n 'state_as_example': state_as_example,\n }","def __init__(self, installation, language, version, parent_shell):\n super(LanguageBase, self).__init__(installation)\n self._language = language\n self._version = version\n self._installation = self._container_dir\n self._parent_shell = parent_shell","def __init__(self, parms, body, env):\n self.parms = parms\n self.body = body\n self.env = env","def __init__(self, evaluation_only=False, seed=0):\n os = platform.system()\n if os == 'Darwin':\n file_name = 'Soccer.app'\n elif os == 'Linux':\n file_name = 'Soccer_Linux/Soccer.x86_64'\n self.env = UnityEnvironment(file_name='unity_envs/' + file_name, seed=seed)\n self.brain_names = self.env.brain_names\n self.evaluation_only = evaluation_only","def scope(self): # noqa: ANN201","def __init__(self):\n self.shell = get_ipython()\n if self.shell is not None:\n self.pt_app = get_app()\n self.session = get_session()\n else:\n from prompt_toolkit import VERSION as ptk_version\n\n # Gonna need a ptk version check\n if ptk_version > 3:\n from prompt_toolkit.application.current import get_app_or_none\n\n self.pt_app = get_app_or_none()\n self.session = self.pt_app.session\n # todo:\n # else:","def __init__(self, engine: str = \"sfdp\"):\n self.engine = engine","def get_environment() -> Environment:\n return Environment(\n media_url=get_endpoint(\"MEDIA\"),\n datastore_reader_url=get_endpoint(\"DATASTORE_READER\"),\n datastore_writer_url=get_endpoint(\"DATASTORE_WRITER\"),\n vote_url=get_endpoint(\"VOTE\"),\n )","def __init__(self, env):\n super().__init__(env)\n self.lives = 0\n self.was_real_done = True","def __init__(self, runtime_dir=\"/tmp/tbots\"):\n\n # inputs to full_system\n self.robot_status_sender = ThreadedUnixSender(runtime_dir + ROBOT_STATUS_PATH)\n self.ssl_wrapper_sender = ThreadedUnixSender(runtime_dir + SSL_WRAPPER_PATH)\n self.ssl_referee_sender = ThreadedUnixSender(runtime_dir + SSL_REFEREE_PATH)\n self.sensor_proto_sender = ThreadedUnixSender(runtime_dir + SENSOR_PROTO_PATH)\n\n # outputs from full_system\n self.world_listener = ThreadedUnixListener(runtime_dir + WORLD_PATH, World)\n self.primitive_listener = ThreadedUnixListener(\n runtime_dir + PRIMITIVE_PATH, PrimitiveSet\n )\n\n # override the tactic\n self.tactic_override = ThreadedUnixSender(runtime_dir + TACTIC_OVERRIDE_PATH)\n\n # TODO (#2510) rename to full_system\n self.full_system_process = Popen([\"software/unix_full_system\"])","def __init__():","def __init__(self):\n BuildSystemBase.__init__(self, \"makefile\")","def __init__(self, env: gym.Env, eval_episodes: int, render_freq: int, \n fps: int, verbose=0):\n super().__init__(verbose=verbose)\n self.env = env\n self.eval_episodes = eval_episodes\n self.render_freq = render_freq\n self.fps = fps","def _base(self):\n pass","def __init__(self, env):\r\n gym.Wrapper.__init__(self, env)\r\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\r\n assert len(env.unwrapped.get_action_meanings()) >= 3","def get_py(self):\n pass","def __init__(self, environ, stdin):\n\n # Request-Line\n # ============\n\n method = environ['REQUEST_METHOD']\n\n path = environ.get('PATH_INFO', '/')\n query = environ.get('QUERY_STRING', '')\n if query:\n query = '?' + query\n raw_uri = environ.get('SCRIPT_NAME', '') + path + query\n uri = urlparse.urlparse(raw_uri)\n keys = ( 'scheme'\n , 'netloc'\n , 'path'\n , 'parameters'\n , 'query'\n , 'fragment'\n )\n _uri = {}\n for i in range(len(uri)):\n k = keys[i]\n v = uri[i]\n _uri[k] = v\n uri = _uri\n\n http_version = environ['SERVER_PROTOCOL']\n\n raw_line = \"%s %s %s\\r\\n\" % (method, raw_uri, http_version)\n\n\n # Headers\n # =======\n\n headers = []\n for k, v in environ.iteritems():\n k = k.lower()\n if k.startswith('http_'):\n as_string = \"%s: %s\" % (k[5:].replace('_','-'), v)\n headers.append(as_string)\n raw_headers = '\\r\\n'.join(headers)\n raw_headers += '\\r\\n'\n headers = message_from_string(raw_headers)\n\n\n # Body\n # ====\n\n raw_body = stdin.read()\n\n\n # Save the API we want.\n # =====================\n\n raw = raw_line + raw_headers + raw_body\n\n self.raw = raw\n self.raw_line = raw_line\n self.raw_headers = raw_headers\n self.raw_body = raw_body\n\n self.method = method\n self.uri = uri\n self.path = path\n self.headers = headers","def __init__(self):\n self.__verbose=False\n self.__fake=False\n self.__all=False\n self.__detector=''\n self.__authpath='.'\n self.__connect=''\n self.__registry={}\n self.__basedir=''\n self.__dbconfig=''","def main(cls):\n raise NotImplementedError","def register_env_creator(self):\n raise NotImplementedError(\"Subclasses should implement this to call ray.tune.registry.register_env\")","def standard_env():\n env = Env()\n\n env.update(vars(math)) # gives us sin, cos, sqrt, pi\n\n env.update({\n '+': op.add, '-': op.sub, '*':op.mul, '/': op.truediv,\n '>': op.gt, '<': op.lt, '>=': op.ge, '<=': op.le, '=': op.eq,\n 'begin': lambda *x: x[-1],\n 'or': op.or_,\n 'even?': lambda x: x % 2 == 0\n })\n return env","def __init__(self, env, key):\n gym.ObservationWrapper.__init__(self, env)\n self.key = key","def __init__(self, env, key):\n gym.ObservationWrapper.__init__(self, env)\n self.key = key","def __init__(self, source_dir, strict=True, interpreter=None, install_dir=None):\r\n self._source_dir = source_dir\r\n self._install_tmp = install_dir or safe_mkdtemp()\r\n self._installed = None\r\n self._strict = strict\r\n self._interpreter = interpreter or PythonInterpreter.get()\r\n if not self._interpreter.satisfies(self.capability) and strict:\r\n raise self.IncapableInterpreter('Interpreter %s not capable of running %s' % (\r\n self._interpreter, self.__class__.__name__))","def __init__(self, name=\"ProRobot\"):\n super().__init__(name)","def environment_variables(self, alias):\n raise NotImplementedError","def __init__(self, *args, **kwargs):\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\n\n self.setOption(\n 'executableName',\n os.environ.get(\n 'KOMBI_PYTHON3_EXECUTABLE',\n 'python3'\n )\n )","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\n assert len(env.unwrapped.get_action_meanings()) >= 3","def __init__(self, env):\n gym.Wrapper.__init__(self, env)\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\n assert len(env.unwrapped.get_action_meanings()) >= 3","def Setup(self):\n raise NotImplementedError(\n 'No runtime setup defined for %s' % self.__class__.__name__)","def __init__(self):\n self.parser_model_dir = None\n self.parser_options = {}\n self.reranker_model = None\n self.unified_model_dir = None","def base():","def _create_extra_environment(self):\n return {}","def __init__(self):\n # env = 'Hexapod-v1'\n env = 'HexapodFewerStatesStandardRL-v1'\n alg = 'ppo2'\n purpose = \"standard-rl\"\n num_timesteps = 1e7\n if_load = False\n play = False\n\n base_path = \"/home/shiqing/gc-batch-rl-locomotion/\"\n date_str = datetime.strftime(datetime.now(), '%Y-%m-%d_%H-%M-%S')\n storage_path = os.path.join(base_path, \"logs\", date_str + \"_\" + env + \"_\" + purpose + \"_\" + alg + \"_\" + str(\"%e\"%num_timesteps))\n if play: storage_path = storage_path + \"_\" + \"play\"\n save_path = os.path.join(storage_path, \"save\")\n log_path = os.path.join(storage_path, \"log\")\n os.mkdir(storage_path)\n os.mkdir(save_path)\n os.mkdir(log_path)\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--env', help='environment ID', type=str, default=env)\n parser.add_argument('--env_type', help='type of environment, used when the environment type cannot be automatically determined', type=str)\n parser.add_argument('--seed', help='RNG seed', type=int, default=0)\n parser.add_argument('--alg', help='Algorithm', type=str, default=alg)\n parser.add_argument('--num_timesteps', type=float, default=num_timesteps),\n parser.add_argument('--network', help='network type (mlp, cnn, lstm, cnn_lstm, conv_only)', default='mlp')\n parser.add_argument('--gamestate', help='game state to load (so far only used in retro games)', default=None)\n parser.add_argument('--num_env', help='Number of environment copies being run in parallel. When not specified, set to number of cpus for Atari, and to 1 for Mujoco', default=None, type=int)\n parser.add_argument('--reward_scale', help='Reward scale factor. Default: 1.0', default=1.0, type=float)\n parser.add_argument('--save_path', help='Path to save trained model to', default=save_path+'/'+ 'model_weights', type=str)\n parser.add_argument('--load_path', help='Path to load trained model from', default='/home/shiqing/gc-batch-rl-locomotion/logs/2020-10-29_00-58-19_HexapodFewerStatesStandardRL-v1_standard-rl_ppo2_4.000000e+06/save/model_weights', type=str)\n parser.add_argument('--save_video_interval', help='Save video every x steps (0 = disabled)', default=0, type=int)\n parser.add_argument('--save_video_length', help='Length of recorded video. Default: 200', default=200, type=int)\n parser.add_argument('--log_path', help='Directory to save learning curve data.', default=log_path, type=str)\n parser.add_argument('--play', default=play)\n parser.add_argument('--if_load', default=if_load)\n\n self.args = parser.parse_args()\n\n #########Extra args (defaults)########\n # extra_args= dict(\n # nsteps=2048,\n # nminibatches=32,\n # lam=0.95,\n # gamma=0.99,\n # noptepochs=10,\n # log_interval=1,\n # ent_coef=0.0,\n # lr=lambda f: 3e-4 * f,\n # cliprange=0.2,\n # value_network='copy')","def __init__(self, herbstclient='herbstclient'):\n self.herbstclient_path = herbstclient\n self.env = None\n self.proc = None","def __init__(self, conf, python, requirements, tagged_env_vars):\n self._env_dir = conf.env_dir\n self._repo_subdir = conf.repo_subdir\n self._install_timeout = conf.install_timeout # gh-391\n self._default_benchmark_timeout = conf.default_benchmark_timeout # gh-973\n self._tagged_env_vars = tagged_env_vars\n self._path = os.path.abspath(os.path.join(\n self._env_dir, self.dir_name))\n self._project = conf.project\n\n self._is_setup = False\n\n self._cache = build_cache.BuildCache(conf, self._path)\n self._build_root = os.path.abspath(os.path.join(self._path, 'project'))\n\n self._requirements = requirements\n # These are needed for asv to build and run the project, not part of\n # benchmark name mangling\n self._base_requirements = {}\n # gh-1314\n asv_runner_path = os.getenv(\"ASV_RUNNER_PATH\", \"\")\n module_path = Path(asv_runner_path) / \"asv_runner\"\n\n # Check if the path points to a directory containing the \"asv_runner\" module\n if module_path.is_dir() and (module_path / \"__init__.py\").is_file():\n spec = importlib.util.spec_from_file_location(\"asv_runner\",\n module_path / \"__init__.py\")\n # Attempt to load the module\n asv_runner_module = importlib.util.module_from_spec(spec)\n try:\n spec.loader.exec_module(asv_runner_module)\n self._base_requirements[\"pip+asv_runner\"] = asv_runner_path\n except Exception as e:\n self._base_requirements[\"pip+asv_runner\"] = \"\"\n log.warning(f\"Failed to load module from ASV_RUNNER_PATH: {e}\")\n else:\n self._base_requirements[\"pip+asv_runner\"] = \"\"\n if asv_runner_path:\n log.warning(\"ASV_RUNNER_PATH does not point\"\n \"to a directory containing the 'asv_runner' module\")\n if not util.ON_PYPY:\n # XXX: What if pypy installed asv tries to benchmark a cpython\n # python?\n self._base_requirements[\"pip+pympler\"] = \"\"\n if (Path.cwd() / \"poetry.lock\").exists():\n self._base_requirements[\"poetry-core\"] = \"\"\n\n if (Path.cwd() / \"pdm.lock\").exists():\n self._base_requirements[\"pdm\"] = \"\"\n\n # Update the _base_requirements if needed\n for key in list(self._requirements.keys()):\n if key in self._base_requirements:\n self._base_requirements[key] = self._requirements[key]\n del self._requirements[key]\n\n self._build_command = conf.build_command\n self._install_command = conf.install_command\n self._uninstall_command = conf.uninstall_command\n\n self._global_env_vars = {}\n self._global_env_vars['ASV'] = 'true'\n self._global_env_vars['ASV_PROJECT'] = conf.project\n self._global_env_vars['ASV_CONF_DIR'] = os.path.abspath(os.getcwd())\n self._global_env_vars['ASV_ENV_NAME'] = self.name\n self._global_env_vars['ASV_ENV_DIR'] = self._path\n self._global_env_vars['ASV_ENV_TYPE'] = self.tool_name\n\n installed_commit_hash = self._get_installed_commit_hash()\n self._set_commit_hash(installed_commit_hash)","def __init__(self, env):\n self._env = env\n self._routes = []\n self._proto = None\n self._port = None\n self._state = False\n self._key = None","def _env_setup(self, initial_qpos):\n raise NotImplementedError()","def user_env(self):\n\n # FIXME I think the JPY_ variables have been deprecated in JupyterHub\n # since 0.7.2, we should replace them. Can we figure this out?\n\n env = super(EC2Spawner, self).get_env()\n env.update(dict(\n JUPYTERHUB_PREFIX=self.hub.server.base_url,\n Name='Jupyter',\n PATH=self.path\n ))\n\n if self.notebook_dir:\n env['NOTEBOOK_DIR'] = self.notebook_dir\n\n hub_api_url = self.hub.api_url\n if self.hub_api_url != '':\n hub_api_url = self.hub_api_url\n\n env['JPY_HUB_API_URL'] = hub_api_url\n env['JUPYTERHUB_API_URL'] = hub_api_url\n\n self.log.debug(\"Env built: {}\".format(env))\n return env","def get_empty_env():\n return EvalEnvironment(namespaces={})","def get_empty_env():\n return EvalEnvironment(namespaces={})","def __init__(self, agent_id=\"default\", experiment_id=\"default\"):\n self.runtime = runtime()\n self.agent_id = agent_id\n self.experiment_id = experiment_id","def __init__(self):\n\n self.config = load_config()\n self.set_env_var()","def __init__(object):"],"string":"[\n \"def __init__(self): \\n\\t\\n\\t # get the environment\\n\\t\\tself.env = env()\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\",\n \"def __init__(self, env):\\n super().__init__(env)\",\n \"def __init__(self, env):\\n super().__init__(env)\",\n \"def __init__(self, env):\\n super().__init__(env)\",\n \"def _run_env(self):\\n raise NotImplementedError()\",\n \"def __init__(self, env):\\n gym.RewardWrapper.__init__(self, env)\",\n \"def __init__(self, env, system=None):\\n self._env = env\\n self._system = system if system is not None else {}\",\n \"def running_environment(self) -> type:\\n return OrdinaryMNLBandit\",\n \"def get_environment():\\n return GenericGymEnv(id=\\\"real-time-gym-v1\\\", gym_kwargs={\\\"config\\\": CONFIG_DICT})\",\n \"def __init__(self, env):\\r\\n gym.Wrapper.__init__(self, env)\\r\\n self.lives = 0\\r\\n self.was_real_done = True\",\n \"def __init__( self ):\\n self._env = None\\n self._steps = None\\n\\n self._initialize( )\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n self.lives = 0\\n self.was_real_done = True\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n self.lives = 0\\n self.was_real_done = True\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n self.lives = 0\\n self.was_real_done = True\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n self.lives = 0\\n self.was_real_done = True\",\n \"def __init__(self, printer):\\n super(BashParentEnvironment, self).__init__()\\n self._printer = printer\",\n \"def __init__(self, template_env):\\r\\n self._template_env = template_env\\r\\n self._pythons = []\",\n \"def __init__(self, \\n ns: str, \\n reward_fnc: str, \\n is_action_space_discrete, \\n safe_dist: float = None, \\n goal_radius: float = 0.1, \\n max_steps_per_episode=100, \\n train_mode: bool = True, \\n debug: bool = False,\\n task_mode: str = \\\"staged\\\",\\n PATHS: dict = dict(),\\n extended_eval: bool = False,\\n *args, **kwargs):\\n super(FlatlandEnv, self).__init__()\\n\\n self.ns = ns\\n try:\\n # given every environment enough time to initialize, if we dont put sleep,\\n # the training script may crash.\\n ns_int = int(ns.split(\\\"_\\\")[1])\\n time.sleep(ns_int*2)\\n except Exception:\\n rospy.logwarn(f\\\"Can't not determinate the number of the environment, training script may crash!\\\")\\n pass\\n\\n\\n # process specific namespace in ros system\\n self.ns_prefix = '' if (ns == '' or ns is None) else '/'+ns+'/'\\n \\n if not debug:\\n if train_mode:\\n rospy.init_node(f'train_env_{self.ns}', disable_signals=False)\\n else:\\n rospy.init_node(f'eval_env_{self.ns}', disable_signals=False)\\n\\n self._extended_eval = extended_eval\\n self._is_train_mode = rospy.get_param(\\\"/train_mode\\\")\\n self._is_action_space_discrete = is_action_space_discrete\\n \\n self.setup_by_configuration(PATHS['robot_setting'], PATHS['robot_as'])\\n\\n # set rosparam\\n rospy.set_param(\\\"/laser_num_beams\\\", self._laser_num_beams)\\n \\n # observation collector\\n self.observation_collector = ObservationCollector(\\n self.ns, self._laser_num_beams, self._laser_max_range)\\n self.observation_space = self.observation_collector.get_observation_space()\\n\\n # reward calculator\\n if safe_dist is None:\\n safe_dist = 1.6*self._robot_radius\\n\\n self.reward_calculator = RewardCalculator(\\n robot_radius=self._robot_radius, safe_dist=1.6*self._robot_radius, goal_radius=goal_radius, \\n rule=reward_fnc, extended_eval=self._extended_eval)\\n\\n # action agent publisher\\n if self._is_train_mode:\\n self.agent_action_pub = rospy.Publisher(f'{self.ns_prefix}cmd_vel', Twist, queue_size=1)\\n else:\\n self.agent_action_pub = rospy.Publisher(f'{self.ns_prefix}cmd_vel_pub', Twist, queue_size=1)\\n\\n # service clients\\n if self._is_train_mode:\\n self._service_name_step = f'{self.ns_prefix}step_world'\\n self._sim_step_client = rospy.ServiceProxy(\\n self._service_name_step, StepWorld)\\n \\n # instantiate task manager\\n self.task = get_predefined_task(\\n ns, mode=task_mode, start_stage=kwargs['curr_stage'], PATHS=PATHS)\\n\\n self._steps_curr_episode = 0\\n self._max_steps_per_episode = max_steps_per_episode\\n\\n # for extended eval\\n self._action_frequency = 1/rospy.get_param(\\\"/robot_action_rate\\\")\\n self._last_robot_pose = None\\n self._distance_travelled = 0\\n self._safe_dist_counter = 0\\n self._collisions = 0\\n self._in_crash = False\",\n \"def base_env(*args, **kwargs):\\n try:\\n # regular gym\\n env = gym.make(*args, **kwargs)\\n except:\\n try:\\n # gym retro\\n env = retro.make(*args, **kwargs)\\n except:\\n # gym-super-mario-bros\\n env = gym_super_mario_bros.make(*args, **kwargs)\\n env.recognized = None\\n return env\",\n \"def __init__(self, printer):\\n super(PowershellParentEnvironment, self).__init__()\\n self._printer = printer\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n # 1st, we will have 2 attributes: self.lives and self.was_real_done\\n self.lives = 0\\n self.was_real_done = True\",\n \"def init():\\n env = Environment(5, 5, 20, [10, 20, 10, 5])\\n return env\",\n \"def standard_env():\\n \\\"\\\"\\\"An environment with some Scheme standard procedures.\\\"\\\"\\\"\\n env = Env()\\n env.update(\\n {\\n \\\"+\\\": op.add,\\n \\\"-\\\": op.sub,\\n \\\"*\\\": op.mul,\\n \\\"/\\\": op.truediv,\\n \\\"car\\\": lambda x: x[0],\\n \\\"cdr\\\": lambda x: x[1:] if len(x) > 2 else x[1],\\n \\\"cons\\\": lambda x, y: [x] + y if isinstance(y, list) else [x, y],\\n \\\"eq?\\\": op.eq,\\n \\\"atom?\\\": lambda x: type(x) in AtomicTypes,\\n }\\n )\\n return env\",\n \"def initialise(self, args, environ):\",\n \"def __init__(self, env):\\n\\n self.env = env\\n self.env_info = env.env_info\\n\\n self.best_policy = None\\n self.best_score = 0\\n\\n # Time to run the environment for during training and evaluation\\n self.max_t = MAX_T\\n # Maximum possible reward given the environment\\n if (self.env.max_reward_per_timestep is None\\n and self.env.max_reward_per_episode is None):\\n raise ValueError(\\\"Either max_reward_per_timestep or \\\"\\n \\\"max_reward_per_episode needs to be set.\\\")\\n elif (self.env.max_reward_per_timestep is None\\n and self.env.max_reward_per_episode is None):\\n raise ValueError(\\\"Either max_reward_per_timestep or \\\"\\n \\\"max_reward_per_episode needs to be None.\\\")\\n elif self.env.max_reward_per_timestep is not None:\\n self.max_reward = self.env.max_reward_per_timestep * self.max_t\\n else:\\n self.max_reward = self.env.max_reward_per_episode\",\n \"def __init__(self,\\n env_name='blobble-world-v0'\\n ):\\n self._env_name = env_name\\n\\n # Take a timestamp. This will be used for any output files created in the output folder\\n self._timestamp = datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M\\\")\\n\\n # Create training and evaluation environments\\n self._train_py_env = suite_gym.load(self._env_name)\\n self._eval_py_env = suite_gym.load(self._env_name)\\n\\n # Convert the training and test environments to Tensors\\n self._train_env = tf_py_environment.TFPyEnvironment(self._train_py_env)\\n self._eval_env = tf_py_environment.TFPyEnvironment(self._eval_py_env)\\n print('=====================================================')\\n print('Environments created for : ', self._env_name)\\n print('Training Environment')\\n print(' Observation Spec:')\\n print(' ', self._train_env.time_step_spec().observation)\\n print(' Reward Spec:')\\n print(' ', self._train_env.time_step_spec().reward)\\n print(' Action Spec:')\\n print(' ', self._train_env.action_spec())\\n print('Evaluation Environment')\\n print(' Observation Spec:')\\n print(' ', self._eval_env.time_step_spec().observation)\\n print(' Reward Spec:')\\n print(' ', self._eval_env.time_step_spec().reward)\\n print(' Action Spec:')\\n print(' ', self._eval_env.action_spec())\\n print('=====================================================')\\n\\n self._config = BlobbleConfig('blobble_config.ini')\\n self._config.print_config()\\n\\n # Get the demonstration parameters and output folder. We don't need these just yet but it's\\n # good to do now in case there is an error in the config file (exception will be thrown)\\n self._output_folder = (self._config.get_output_params()['output_folder'])\\n\\n self._num_demo_episodes = int(self._config.get_output_params()['num_demonstration_episodes'])\\n demo_video = (self._config.get_output_params()['demonstration_video'])\\n if demo_video == 'True':\\n self._demo_video = True\\n else:\\n self._demo_video = False\\n\\n # Get and check the advanced learning parameters\\n self._learning_rate = float(self._config.get_learning_adv_params()['learning_rate'])\\n self._fc_layer_params = tuple(self._config.get_learning_adv_params()['fc_layer_params'].split(','))\\n\\n print('Create and train a neural network agent')\\n self._neural_network_agent = create_neural_network_agent(self._train_env,\\n self._learning_rate,\\n self._fc_layer_params)\\n\\n learning_params = self._config.get_learning_params()\\n train_neural_network(self._neural_network_agent,\\n self._train_env,\\n self._eval_env,\\n num_train_iterations=learning_params['training_iterations'],\\n log_interval=learning_params['training_log_interval'],\\n eval_interval=learning_params['eval_interval'],\\n num_eval_episodes=learning_params['num_eval_episodes'],\\n replay_buffer_max_length=learning_params['replay_buffer_max_length'],\\n collect_steps_per_iteration=learning_params['collect_steps_per_iteration'],\\n output_folder=self._output_folder,\\n timestamp=self._timestamp)\",\n \"def env(self) -> Optional[Env]:\\n raise NotImplementedError\",\n \"def _get_environment(cls):\\n return cls.__name__.lower()\",\n \"def SetupEnvironment(self):\\n pass\",\n \"def getEnvironment(self):\\n pass\",\n \"def __init__(self, *args):\\n self.env = os.environ.copy()\\n \\\"\\\"\\\"Environment variables (:class:`dict`)\\\"\\\"\\\"\\n command = \\\"modulecmd python \\\"+' '.join(args)\\n p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)\\n retval = p.communicate()\\n self._parse(retval)\",\n \"def step_env(self):\\n raise NotImplementedError\\n # Not needed for this homework\",\n \"def __init__(self, max_step=-1):\\n self.environment = mls.rl.common.Environment()\\n self.environment.game = mls.rl.common.Game(max_step=max_step)\\n self.environment.current_state = self.environment.game.init_state(self.environment)\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: EnvironmentArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def __init__(self):\\n self._opts = {} # dict of dicts of (opt:, override:, default:)\\n self._groups = {}\\n self._deprecated_opts = {}\\n\\n self._args = None\\n\\n self._oparser = None\\n self._namespace = None\\n self._mutable_ns = None\\n self._mutate_hooks = set([])\\n self.__cache = {}\\n self.__drivers_cache = {}\\n self._config_opts = []\\n self._cli_opts = collections.deque()\\n self._validate_default_values = False\\n self._sources = []\\n self._ext_mgr = None\\n # Though the env_driver is a Source, we load it by default.\\n self._use_env = True\\n self._env_driver = _environment.EnvironmentConfigurationSource()\\n\\n self.register_opt(self._config_source_opt)\",\n \"def __init__(self, model: WorldModel, real_env: ModelBasedEnv):\\n super(VirtualEnv, self).__init__()\\n self.action_space = real_env.action_space\\n self.observation_space = real_env.observation_space\\n self.reward_range = real_env.reward_range\\n self.cost_fn = real_env.cost_fn\\n self.model = model\\n self.current_state = None\\n\\n self.initial_states_pool = None\\n\\n if real_env.spec is not None and hasattr(real_env.spec, 'max_episode_steps'):\\n self.max_episode_steps = real_env.spec.max_episode_steps\\n else:\\n self.max_episode_steps = float('inf')\",\n \"def __MakeEnvironment(self):\\n environment= os.environ.copy()\\n\\n for key, value in self.__context.items():\\n if type(value) is str:\\n name = \\\"QMV_\\\" + key.replace(\\\".\\\", \\\"__\\\")\\n environment[name]= value\\n\\n return environment\",\n \"def __init__(self):\\n # Select all the environment variables starting with 'ASH_CFG_' and strip\\n # off the leading ASH_CFG_ portion to use as the name of the variable.\\n self.variables = dict(\\n [(x[8:], y) for x, y in os.environ.items() if x.startswith('ASH_CFG_')]\\n )\",\n \"def __init__(self, env, noop_max=30):\\n gym.Wrapper.__init__(self, env)\\n self.noop_max = noop_max\\n self.override_num_noops = None\\n self.noop_action = 0\",\n \"def __init__(self, environment_variables=None, var_prefix='PLATFORM_'):\\n\\n self._environmentVariables = os.environ if environment_variables is None else environment_variables\\n self._varPrefix = var_prefix\\n\\n if self['ROUTES']:\\n routes = self['ROUTES']\\n self._routesDef = self.decode(routes)\\n if self['RELATIONSHIPS']:\\n relationships = self['RELATIONSHIPS']\\n self._relationshipsDef = self.decode(relationships)\\n self.register_formatter('pymongo', pymongo_formatter)\\n self.register_formatter('pysolr', pysolr_formatter)\\n self.register_formatter('postgresql_dsn', posgresql_dsn_formatter)\\n\\n if self['VARIABLES']:\\n variables = self['VARIABLES']\\n self._variablesDef = self.decode(variables)\\n if self['APPLICATION']:\\n application = self['APPLICATION']\\n self._applicationDef = self.decode(application)\",\n \"def __init__(self, step_runner, properties, environ, universe_view,\\n engine_flags=None):\\n self._step_runner = step_runner\\n self._properties = properties\\n self._environ = environ.copy()\\n self._universe_view = universe_view\\n self._clients = {client.IDENT: client for client in (\\n recipe_api.DependencyManagerClient(self),\\n recipe_api.PathsClient(),\\n recipe_api.PropertiesClient(self),\\n recipe_api.SourceManifestClient(self, properties),\\n recipe_api.StepClient(self),\\n )}\\n self._engine_flags = engine_flags\\n\\n # A stack of ActiveStep objects, holding the most recently executed step at\\n # each nest level (objects deeper in the stack have lower nest levels).\\n # When we pop from this stack, we close the corresponding step stream.\\n self._step_stack = []\",\n \"def __attrs_post_init__(self):\\n self.path = (Path(CONFIG['conda_folder']) / 'envs' / self.name)\",\n \"def initialize():\\n environment = Environment()\\n environment.setup()\",\n \"def __init__(self, name=None):\\n super(TTSEngine, self).__init__()\",\n \"def __init__(__self__, *,\\n application_name: pulumi.Input[str],\\n cname_prefix: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n environment_name: Optional[pulumi.Input[str]] = None,\\n operations_role: Optional[pulumi.Input[str]] = None,\\n option_settings: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentOptionSettingArgs']]]] = None,\\n platform_arn: Optional[pulumi.Input[str]] = None,\\n solution_stack_name: Optional[pulumi.Input[str]] = None,\\n tags: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentTagArgs']]]] = None,\\n template_name: Optional[pulumi.Input[str]] = None,\\n tier: Optional[pulumi.Input['EnvironmentTierArgs']] = None,\\n version_label: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"application_name\\\", application_name)\\n if cname_prefix is not None:\\n pulumi.set(__self__, \\\"cname_prefix\\\", cname_prefix)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if environment_name is not None:\\n pulumi.set(__self__, \\\"environment_name\\\", environment_name)\\n if operations_role is not None:\\n pulumi.set(__self__, \\\"operations_role\\\", operations_role)\\n if option_settings is not None:\\n pulumi.set(__self__, \\\"option_settings\\\", option_settings)\\n if platform_arn is not None:\\n pulumi.set(__self__, \\\"platform_arn\\\", platform_arn)\\n if solution_stack_name is not None:\\n pulumi.set(__self__, \\\"solution_stack_name\\\", solution_stack_name)\\n if tags is not None:\\n pulumi.set(__self__, \\\"tags\\\", tags)\\n if template_name is not None:\\n pulumi.set(__self__, \\\"template_name\\\", template_name)\\n if tier is not None:\\n pulumi.set(__self__, \\\"tier\\\", tier)\\n if version_label is not None:\\n pulumi.set(__self__, \\\"version_label\\\", version_label)\",\n \"def make_problem_service(config: ProblemServiceConfig):\\n\\n class ProblemService(rpyc.Service):\\n \\\"\\\"\\\"Spools up a new Python interpreter and uses it to sandbox SSiPP and\\n MDPSim. Can interact with this to train a Q-network.\\\"\\\"\\\"\\n\\n # TODO: figure out some way of ensuring that arguments and return\\n # values are deep-copied, or the whole impl will end up dog slow.\\n\\n def exposed_extend_replay(self, get_action, n_paths):\\n \\\"\\\"\\\"Extend the replay buffer using the given policy (represented as a\\n function from flattened observation vectors to action numbenrs).\\\"\\\"\\\"\\n n_paths = to_local(n_paths)\\n return self.internal_extend_replay(get_action, n_paths)\\n\\n def exposed_batch_iter(self, batch_size, n_batches):\\n \\\"\\\"\\\"Sample <batch_size> elements from internal buffer.\\\"\\\"\\\"\\n batch_size = to_local(batch_size)\\n n_batches = to_local(n_batches)\\n # first convert replay buffer to a list so that we can shuffle and\\n # take indices\\n assert len(self.replay) > 0, 'need non-empty replay pool'\\n ordered_buf = list(self.replay)\\n shuffle(ordered_buf) # in-place\\n gen = cycle(ordered_buf)\\n for batch_num in range(n_batches):\\n rich_batch = list(islice(gen, batch_size))\\n yield self.flatten_batch(rich_batch)\\n\\n def exposed_env_reset(self):\\n return self.env_wrapped.reset()\\n\\n def exposed_action_name(self, action_num):\\n action_num = to_local(action_num)\\n return self.env_raw.action_name(action_num)\\n\\n def exposed_env_step(self, action):\\n action = to_local(action)\\n return self.env_wrapped.step(action)\\n\\n # note to self: RPyC doesn't support @property\\n\\n def exposed_get_ssipp_dead_end_value(self):\\n return self.p.ssipp_dead_end_value\\n\\n def exposed_get_meta(self):\\n \\\"\\\"\\\"Get name, ProblemMeta and DomainMeta for the current problem.\\\"\\\"\\\"\\n return self.problem_meta, self.domain_meta\\n\\n def exposed_get_replay_size(self):\\n return len(self.replay)\\n\\n def exposed_get_env_spec(self):\\n # this will have to be deep-copied to actually work (I think)\\n return self.env_wrapped.spec\\n\\n def exposed_get_obs_dim(self):\\n return self.env_wrapped.observation_space.flat_dim\\n\\n def exposed_get_act_dim(self):\\n return self.env_wrapped.action_space.flat_dim\\n\\n def exposed_get_obs_dtype_name(self):\\n return self.env_wrapped.observation_space.dtype.name\\n\\n def exposed_get_dg_extra_dim(self):\\n data_gens = self.env_raw.data_gens\\n return sum([g.extra_dim for g in data_gens])\\n\\n def exposed_get_max_len(self):\\n return self.max_len\\n\\n def exposed_get_problem_names(self):\\n # fetch a list of all problems loaded by MDPSim\\n return sorted(self.p.mdpsim.get_problems().keys())\\n\\n def exposed_get_current_problem_name(self):\\n return self.p.problem_name\\n\\n def on_connect(self):\\n self.p = PlannerExtensions(config.pddl_files,\\n config.init_problem_name)\\n mdpsim_p = self.p.mdpsim_problem\\n self.domain_meta = get_domain_meta(mdpsim_p.domain)\\n self.problem_meta = get_problem_meta(mdpsim_p, self.domain_meta)\\n self.env_raw, self.env_wrapped = create_environment(\\n problem_meta=self.problem_meta,\\n planner_extensions=self.p,\\n heuristic_name=config.heuristic_name,\\n use_lm_cuts=config.use_lm_cuts,\\n dump_table_path=config.dump_table_path,\\n dump_table_interval=config.dump_table_interval)\\n self.planner = Planner(self.p, 'lrtdp', config.teacher_heur)\\n\\n # maximum length of a trace to gather\\n self.max_len = config.max_len\\n # will hold (state, action) pairs to train on\\n self.replay = set() # type: Set[StateQVs]\\n\\n @lru_cache(None)\\n def opt_pol_envelope(self, obs: FPGObservation) -> List[StateQVs]:\\n \\\"\\\"\\\"Get (s, a) pairs for optimal policy from given state.\\\"\\\"\\\"\\n return planner_trace(self.planner, self.problem_meta,\\n self.p.mdpsim_problem, obs)\\n\\n def internal_extend_replay(self, get_action: Any, n_paths: int) \\\\\\n -> float:\\n \\\"\\\"\\\"Extend the supervision buffer with some new paths. Can probably make\\n this more sophisticated by turning it into a least-recently-visited\\n cache or something.\\\"\\\"\\\"\\n paths, succ_rate = collect_paths(\\n rllab_env=self.env_wrapped,\\n prob_meta=self.problem_meta,\\n get_action=get_action,\\n n_paths=n_paths,\\n max_len=self.max_len)\\n new_pairs = set()\\n for path in paths:\\n # ignore original action\\n for obs, _ in path:\\n # I used to hard negative mine (only add to training set if\\n # net gets it wrong), but now I don't bother\\n new_pairs.update(self.opt_pol_envelope(obs))\\n self.replay.update(new_pairs)\\n return succ_rate\\n\\n def flatten_batch(self, rich_batch: List[StateQVs]) \\\\\\n -> Tuple[np.ndarray, np.ndarray]:\\n rich_obs, rich_qvs = zip(*rich_batch)\\n obs_tensor = self.env_raw.observation_space.flatten_n(rich_obs)\\n qv_lists = []\\n for qv_pairs in rich_qvs:\\n qv_dict = dict(qv_pairs)\\n qv_list = [\\n qv_dict[ba] for ba in self.problem_meta.bound_acts_ordered\\n ]\\n qv_lists.append(qv_list)\\n qv_tensor = np.array(qv_lists)\\n return obs_tensor, qv_tensor\\n\\n return ProblemService\",\n \"def set_pyenv_cfg(self): # noqa: D205\\n super().set_pyenv_cfg()\\n self.pyenv_cfg[\\\"base-prefix\\\"] = self.interpreter.system_prefix\\n self.pyenv_cfg[\\\"base-exec-prefix\\\"] = self.interpreter.system_exec_prefix\\n self.pyenv_cfg[\\\"base-executable\\\"] = self.interpreter.system_executable\",\n \"def cli(self, env):\\n raise NotImplementedError\",\n \"def __init__(self):\\n # The current information for the environment\\n self.state_space = ()\\n self.action_space = ()\\n self.state = None\\n self.reward = 0\\n self.terminal = False\\n self.truncated = False\\n self.info = None\",\n \"def make_env():\\n return {\\n 'init': init,\\n 'step': step,\\n 'is_terminal': is_terminal,\\n 'state_as_example': state_as_example,\\n }\",\n \"def __init__(self, installation, language, version, parent_shell):\\n super(LanguageBase, self).__init__(installation)\\n self._language = language\\n self._version = version\\n self._installation = self._container_dir\\n self._parent_shell = parent_shell\",\n \"def __init__(self, parms, body, env):\\n self.parms = parms\\n self.body = body\\n self.env = env\",\n \"def __init__(self, evaluation_only=False, seed=0):\\n os = platform.system()\\n if os == 'Darwin':\\n file_name = 'Soccer.app'\\n elif os == 'Linux':\\n file_name = 'Soccer_Linux/Soccer.x86_64'\\n self.env = UnityEnvironment(file_name='unity_envs/' + file_name, seed=seed)\\n self.brain_names = self.env.brain_names\\n self.evaluation_only = evaluation_only\",\n \"def scope(self): # noqa: ANN201\",\n \"def __init__(self):\\n self.shell = get_ipython()\\n if self.shell is not None:\\n self.pt_app = get_app()\\n self.session = get_session()\\n else:\\n from prompt_toolkit import VERSION as ptk_version\\n\\n # Gonna need a ptk version check\\n if ptk_version > 3:\\n from prompt_toolkit.application.current import get_app_or_none\\n\\n self.pt_app = get_app_or_none()\\n self.session = self.pt_app.session\\n # todo:\\n # else:\",\n \"def __init__(self, engine: str = \\\"sfdp\\\"):\\n self.engine = engine\",\n \"def get_environment() -> Environment:\\n return Environment(\\n media_url=get_endpoint(\\\"MEDIA\\\"),\\n datastore_reader_url=get_endpoint(\\\"DATASTORE_READER\\\"),\\n datastore_writer_url=get_endpoint(\\\"DATASTORE_WRITER\\\"),\\n vote_url=get_endpoint(\\\"VOTE\\\"),\\n )\",\n \"def __init__(self, env):\\n super().__init__(env)\\n self.lives = 0\\n self.was_real_done = True\",\n \"def __init__(self, runtime_dir=\\\"/tmp/tbots\\\"):\\n\\n # inputs to full_system\\n self.robot_status_sender = ThreadedUnixSender(runtime_dir + ROBOT_STATUS_PATH)\\n self.ssl_wrapper_sender = ThreadedUnixSender(runtime_dir + SSL_WRAPPER_PATH)\\n self.ssl_referee_sender = ThreadedUnixSender(runtime_dir + SSL_REFEREE_PATH)\\n self.sensor_proto_sender = ThreadedUnixSender(runtime_dir + SENSOR_PROTO_PATH)\\n\\n # outputs from full_system\\n self.world_listener = ThreadedUnixListener(runtime_dir + WORLD_PATH, World)\\n self.primitive_listener = ThreadedUnixListener(\\n runtime_dir + PRIMITIVE_PATH, PrimitiveSet\\n )\\n\\n # override the tactic\\n self.tactic_override = ThreadedUnixSender(runtime_dir + TACTIC_OVERRIDE_PATH)\\n\\n # TODO (#2510) rename to full_system\\n self.full_system_process = Popen([\\\"software/unix_full_system\\\"])\",\n \"def __init__():\",\n \"def __init__(self):\\n BuildSystemBase.__init__(self, \\\"makefile\\\")\",\n \"def __init__(self, env: gym.Env, eval_episodes: int, render_freq: int, \\n fps: int, verbose=0):\\n super().__init__(verbose=verbose)\\n self.env = env\\n self.eval_episodes = eval_episodes\\n self.render_freq = render_freq\\n self.fps = fps\",\n \"def _base(self):\\n pass\",\n \"def __init__(self, env):\\r\\n gym.Wrapper.__init__(self, env)\\r\\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\\r\\n assert len(env.unwrapped.get_action_meanings()) >= 3\",\n \"def get_py(self):\\n pass\",\n \"def __init__(self, environ, stdin):\\n\\n # Request-Line\\n # ============\\n\\n method = environ['REQUEST_METHOD']\\n\\n path = environ.get('PATH_INFO', '/')\\n query = environ.get('QUERY_STRING', '')\\n if query:\\n query = '?' + query\\n raw_uri = environ.get('SCRIPT_NAME', '') + path + query\\n uri = urlparse.urlparse(raw_uri)\\n keys = ( 'scheme'\\n , 'netloc'\\n , 'path'\\n , 'parameters'\\n , 'query'\\n , 'fragment'\\n )\\n _uri = {}\\n for i in range(len(uri)):\\n k = keys[i]\\n v = uri[i]\\n _uri[k] = v\\n uri = _uri\\n\\n http_version = environ['SERVER_PROTOCOL']\\n\\n raw_line = \\\"%s %s %s\\\\r\\\\n\\\" % (method, raw_uri, http_version)\\n\\n\\n # Headers\\n # =======\\n\\n headers = []\\n for k, v in environ.iteritems():\\n k = k.lower()\\n if k.startswith('http_'):\\n as_string = \\\"%s: %s\\\" % (k[5:].replace('_','-'), v)\\n headers.append(as_string)\\n raw_headers = '\\\\r\\\\n'.join(headers)\\n raw_headers += '\\\\r\\\\n'\\n headers = message_from_string(raw_headers)\\n\\n\\n # Body\\n # ====\\n\\n raw_body = stdin.read()\\n\\n\\n # Save the API we want.\\n # =====================\\n\\n raw = raw_line + raw_headers + raw_body\\n\\n self.raw = raw\\n self.raw_line = raw_line\\n self.raw_headers = raw_headers\\n self.raw_body = raw_body\\n\\n self.method = method\\n self.uri = uri\\n self.path = path\\n self.headers = headers\",\n \"def __init__(self):\\n self.__verbose=False\\n self.__fake=False\\n self.__all=False\\n self.__detector=''\\n self.__authpath='.'\\n self.__connect=''\\n self.__registry={}\\n self.__basedir=''\\n self.__dbconfig=''\",\n \"def main(cls):\\n raise NotImplementedError\",\n \"def register_env_creator(self):\\n raise NotImplementedError(\\\"Subclasses should implement this to call ray.tune.registry.register_env\\\")\",\n \"def standard_env():\\n env = Env()\\n\\n env.update(vars(math)) # gives us sin, cos, sqrt, pi\\n\\n env.update({\\n '+': op.add, '-': op.sub, '*':op.mul, '/': op.truediv,\\n '>': op.gt, '<': op.lt, '>=': op.ge, '<=': op.le, '=': op.eq,\\n 'begin': lambda *x: x[-1],\\n 'or': op.or_,\\n 'even?': lambda x: x % 2 == 0\\n })\\n return env\",\n \"def __init__(self, env, key):\\n gym.ObservationWrapper.__init__(self, env)\\n self.key = key\",\n \"def __init__(self, env, key):\\n gym.ObservationWrapper.__init__(self, env)\\n self.key = key\",\n \"def __init__(self, source_dir, strict=True, interpreter=None, install_dir=None):\\r\\n self._source_dir = source_dir\\r\\n self._install_tmp = install_dir or safe_mkdtemp()\\r\\n self._installed = None\\r\\n self._strict = strict\\r\\n self._interpreter = interpreter or PythonInterpreter.get()\\r\\n if not self._interpreter.satisfies(self.capability) and strict:\\r\\n raise self.IncapableInterpreter('Interpreter %s not capable of running %s' % (\\r\\n self._interpreter, self.__class__.__name__))\",\n \"def __init__(self, name=\\\"ProRobot\\\"):\\n super().__init__(name)\",\n \"def environment_variables(self, alias):\\n raise NotImplementedError\",\n \"def __init__(self, *args, **kwargs):\\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\\n\\n self.setOption(\\n 'executableName',\\n os.environ.get(\\n 'KOMBI_PYTHON3_EXECUTABLE',\\n 'python3'\\n )\\n )\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\\n assert len(env.unwrapped.get_action_meanings()) >= 3\",\n \"def __init__(self, env):\\n gym.Wrapper.__init__(self, env)\\n assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\\n assert len(env.unwrapped.get_action_meanings()) >= 3\",\n \"def Setup(self):\\n raise NotImplementedError(\\n 'No runtime setup defined for %s' % self.__class__.__name__)\",\n \"def __init__(self):\\n self.parser_model_dir = None\\n self.parser_options = {}\\n self.reranker_model = None\\n self.unified_model_dir = None\",\n \"def base():\",\n \"def _create_extra_environment(self):\\n return {}\",\n \"def __init__(self):\\n # env = 'Hexapod-v1'\\n env = 'HexapodFewerStatesStandardRL-v1'\\n alg = 'ppo2'\\n purpose = \\\"standard-rl\\\"\\n num_timesteps = 1e7\\n if_load = False\\n play = False\\n\\n base_path = \\\"/home/shiqing/gc-batch-rl-locomotion/\\\"\\n date_str = datetime.strftime(datetime.now(), '%Y-%m-%d_%H-%M-%S')\\n storage_path = os.path.join(base_path, \\\"logs\\\", date_str + \\\"_\\\" + env + \\\"_\\\" + purpose + \\\"_\\\" + alg + \\\"_\\\" + str(\\\"%e\\\"%num_timesteps))\\n if play: storage_path = storage_path + \\\"_\\\" + \\\"play\\\"\\n save_path = os.path.join(storage_path, \\\"save\\\")\\n log_path = os.path.join(storage_path, \\\"log\\\")\\n os.mkdir(storage_path)\\n os.mkdir(save_path)\\n os.mkdir(log_path)\\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--env', help='environment ID', type=str, default=env)\\n parser.add_argument('--env_type', help='type of environment, used when the environment type cannot be automatically determined', type=str)\\n parser.add_argument('--seed', help='RNG seed', type=int, default=0)\\n parser.add_argument('--alg', help='Algorithm', type=str, default=alg)\\n parser.add_argument('--num_timesteps', type=float, default=num_timesteps),\\n parser.add_argument('--network', help='network type (mlp, cnn, lstm, cnn_lstm, conv_only)', default='mlp')\\n parser.add_argument('--gamestate', help='game state to load (so far only used in retro games)', default=None)\\n parser.add_argument('--num_env', help='Number of environment copies being run in parallel. When not specified, set to number of cpus for Atari, and to 1 for Mujoco', default=None, type=int)\\n parser.add_argument('--reward_scale', help='Reward scale factor. Default: 1.0', default=1.0, type=float)\\n parser.add_argument('--save_path', help='Path to save trained model to', default=save_path+'/'+ 'model_weights', type=str)\\n parser.add_argument('--load_path', help='Path to load trained model from', default='/home/shiqing/gc-batch-rl-locomotion/logs/2020-10-29_00-58-19_HexapodFewerStatesStandardRL-v1_standard-rl_ppo2_4.000000e+06/save/model_weights', type=str)\\n parser.add_argument('--save_video_interval', help='Save video every x steps (0 = disabled)', default=0, type=int)\\n parser.add_argument('--save_video_length', help='Length of recorded video. Default: 200', default=200, type=int)\\n parser.add_argument('--log_path', help='Directory to save learning curve data.', default=log_path, type=str)\\n parser.add_argument('--play', default=play)\\n parser.add_argument('--if_load', default=if_load)\\n\\n self.args = parser.parse_args()\\n\\n #########Extra args (defaults)########\\n # extra_args= dict(\\n # nsteps=2048,\\n # nminibatches=32,\\n # lam=0.95,\\n # gamma=0.99,\\n # noptepochs=10,\\n # log_interval=1,\\n # ent_coef=0.0,\\n # lr=lambda f: 3e-4 * f,\\n # cliprange=0.2,\\n # value_network='copy')\",\n \"def __init__(self, herbstclient='herbstclient'):\\n self.herbstclient_path = herbstclient\\n self.env = None\\n self.proc = None\",\n \"def __init__(self, conf, python, requirements, tagged_env_vars):\\n self._env_dir = conf.env_dir\\n self._repo_subdir = conf.repo_subdir\\n self._install_timeout = conf.install_timeout # gh-391\\n self._default_benchmark_timeout = conf.default_benchmark_timeout # gh-973\\n self._tagged_env_vars = tagged_env_vars\\n self._path = os.path.abspath(os.path.join(\\n self._env_dir, self.dir_name))\\n self._project = conf.project\\n\\n self._is_setup = False\\n\\n self._cache = build_cache.BuildCache(conf, self._path)\\n self._build_root = os.path.abspath(os.path.join(self._path, 'project'))\\n\\n self._requirements = requirements\\n # These are needed for asv to build and run the project, not part of\\n # benchmark name mangling\\n self._base_requirements = {}\\n # gh-1314\\n asv_runner_path = os.getenv(\\\"ASV_RUNNER_PATH\\\", \\\"\\\")\\n module_path = Path(asv_runner_path) / \\\"asv_runner\\\"\\n\\n # Check if the path points to a directory containing the \\\"asv_runner\\\" module\\n if module_path.is_dir() and (module_path / \\\"__init__.py\\\").is_file():\\n spec = importlib.util.spec_from_file_location(\\\"asv_runner\\\",\\n module_path / \\\"__init__.py\\\")\\n # Attempt to load the module\\n asv_runner_module = importlib.util.module_from_spec(spec)\\n try:\\n spec.loader.exec_module(asv_runner_module)\\n self._base_requirements[\\\"pip+asv_runner\\\"] = asv_runner_path\\n except Exception as e:\\n self._base_requirements[\\\"pip+asv_runner\\\"] = \\\"\\\"\\n log.warning(f\\\"Failed to load module from ASV_RUNNER_PATH: {e}\\\")\\n else:\\n self._base_requirements[\\\"pip+asv_runner\\\"] = \\\"\\\"\\n if asv_runner_path:\\n log.warning(\\\"ASV_RUNNER_PATH does not point\\\"\\n \\\"to a directory containing the 'asv_runner' module\\\")\\n if not util.ON_PYPY:\\n # XXX: What if pypy installed asv tries to benchmark a cpython\\n # python?\\n self._base_requirements[\\\"pip+pympler\\\"] = \\\"\\\"\\n if (Path.cwd() / \\\"poetry.lock\\\").exists():\\n self._base_requirements[\\\"poetry-core\\\"] = \\\"\\\"\\n\\n if (Path.cwd() / \\\"pdm.lock\\\").exists():\\n self._base_requirements[\\\"pdm\\\"] = \\\"\\\"\\n\\n # Update the _base_requirements if needed\\n for key in list(self._requirements.keys()):\\n if key in self._base_requirements:\\n self._base_requirements[key] = self._requirements[key]\\n del self._requirements[key]\\n\\n self._build_command = conf.build_command\\n self._install_command = conf.install_command\\n self._uninstall_command = conf.uninstall_command\\n\\n self._global_env_vars = {}\\n self._global_env_vars['ASV'] = 'true'\\n self._global_env_vars['ASV_PROJECT'] = conf.project\\n self._global_env_vars['ASV_CONF_DIR'] = os.path.abspath(os.getcwd())\\n self._global_env_vars['ASV_ENV_NAME'] = self.name\\n self._global_env_vars['ASV_ENV_DIR'] = self._path\\n self._global_env_vars['ASV_ENV_TYPE'] = self.tool_name\\n\\n installed_commit_hash = self._get_installed_commit_hash()\\n self._set_commit_hash(installed_commit_hash)\",\n \"def __init__(self, env):\\n self._env = env\\n self._routes = []\\n self._proto = None\\n self._port = None\\n self._state = False\\n self._key = None\",\n \"def _env_setup(self, initial_qpos):\\n raise NotImplementedError()\",\n \"def user_env(self):\\n\\n # FIXME I think the JPY_ variables have been deprecated in JupyterHub\\n # since 0.7.2, we should replace them. Can we figure this out?\\n\\n env = super(EC2Spawner, self).get_env()\\n env.update(dict(\\n JUPYTERHUB_PREFIX=self.hub.server.base_url,\\n Name='Jupyter',\\n PATH=self.path\\n ))\\n\\n if self.notebook_dir:\\n env['NOTEBOOK_DIR'] = self.notebook_dir\\n\\n hub_api_url = self.hub.api_url\\n if self.hub_api_url != '':\\n hub_api_url = self.hub_api_url\\n\\n env['JPY_HUB_API_URL'] = hub_api_url\\n env['JUPYTERHUB_API_URL'] = hub_api_url\\n\\n self.log.debug(\\\"Env built: {}\\\".format(env))\\n return env\",\n \"def get_empty_env():\\n return EvalEnvironment(namespaces={})\",\n \"def get_empty_env():\\n return EvalEnvironment(namespaces={})\",\n \"def __init__(self, agent_id=\\\"default\\\", experiment_id=\\\"default\\\"):\\n self.runtime = runtime()\\n self.agent_id = agent_id\\n self.experiment_id = experiment_id\",\n \"def __init__(self):\\n\\n self.config = load_config()\\n self.set_env_var()\",\n \"def __init__(object):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68557495","0.66981584","0.66981584","0.66636485","0.66636485","0.66636485","0.6464115","0.616451","0.6071239","0.5907203","0.589397","0.58922243","0.58735794","0.58711684","0.58711684","0.58711684","0.58711684","0.58711684","0.58711684","0.5841212","0.5841212","0.5832843","0.5832843","0.58098954","0.57577604","0.56992954","0.5657971","0.5650119","0.56304014","0.5618274","0.56020564","0.5596296","0.55683327","0.55449563","0.5544772","0.55331326","0.55248123","0.55241865","0.5516979","0.55163074","0.5468055","0.54613525","0.5453816","0.5452291","0.5451629","0.54513377","0.54403","0.54392517","0.54213804","0.542035","0.54173666","0.5410413","0.5403248","0.5387881","0.5384381","0.537894","0.5376007","0.5373222","0.5358999","0.53305006","0.5328333","0.5323135","0.5319307","0.53130233","0.53086436","0.53054","0.53033555","0.52972734","0.5296905","0.52761036","0.5268875","0.52669555","0.5257173","0.5256486","0.5236418","0.5234417","0.5225822","0.5219782","0.5215224","0.5215224","0.52119434","0.52106225","0.5200898","0.5197508","0.5196801","0.5196801","0.5186255","0.51714736","0.516971","0.51684445","0.51646864","0.51578754","0.51563543","0.5151843","0.51499724","0.5146501","0.5140478","0.5140478","0.5136346","0.51337147","0.51314086"],"string":"[\n \"0.68557495\",\n \"0.66981584\",\n \"0.66981584\",\n \"0.66636485\",\n \"0.66636485\",\n \"0.66636485\",\n \"0.6464115\",\n \"0.616451\",\n \"0.6071239\",\n \"0.5907203\",\n \"0.589397\",\n \"0.58922243\",\n \"0.58735794\",\n \"0.58711684\",\n \"0.58711684\",\n \"0.58711684\",\n \"0.58711684\",\n \"0.58711684\",\n \"0.58711684\",\n \"0.5841212\",\n \"0.5841212\",\n \"0.5832843\",\n \"0.5832843\",\n \"0.58098954\",\n \"0.57577604\",\n \"0.56992954\",\n \"0.5657971\",\n \"0.5650119\",\n \"0.56304014\",\n \"0.5618274\",\n \"0.56020564\",\n \"0.5596296\",\n \"0.55683327\",\n \"0.55449563\",\n \"0.5544772\",\n \"0.55331326\",\n \"0.55248123\",\n \"0.55241865\",\n \"0.5516979\",\n \"0.55163074\",\n \"0.5468055\",\n \"0.54613525\",\n \"0.5453816\",\n \"0.5452291\",\n \"0.5451629\",\n \"0.54513377\",\n \"0.54403\",\n \"0.54392517\",\n \"0.54213804\",\n \"0.542035\",\n \"0.54173666\",\n \"0.5410413\",\n \"0.5403248\",\n \"0.5387881\",\n \"0.5384381\",\n \"0.537894\",\n \"0.5376007\",\n \"0.5373222\",\n \"0.5358999\",\n \"0.53305006\",\n \"0.5328333\",\n \"0.5323135\",\n \"0.5319307\",\n \"0.53130233\",\n \"0.53086436\",\n \"0.53054\",\n \"0.53033555\",\n \"0.52972734\",\n \"0.5296905\",\n \"0.52761036\",\n \"0.5268875\",\n \"0.52669555\",\n \"0.5257173\",\n \"0.5256486\",\n \"0.5236418\",\n \"0.5234417\",\n \"0.5225822\",\n \"0.5219782\",\n \"0.5215224\",\n \"0.5215224\",\n \"0.52119434\",\n \"0.52106225\",\n \"0.5200898\",\n \"0.5197508\",\n \"0.5196801\",\n \"0.5196801\",\n \"0.5186255\",\n \"0.51714736\",\n \"0.516971\",\n \"0.51684445\",\n \"0.51646864\",\n \"0.51578754\",\n \"0.51563543\",\n \"0.5151843\",\n \"0.51499724\",\n \"0.5146501\",\n \"0.5140478\",\n \"0.5140478\",\n \"0.5136346\",\n \"0.51337147\",\n \"0.51314086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4197,"cells":{"query":{"kind":"string","value":"Whether the environment is batched or not. If the environment supports batched observations and actions, then overwrite this property to True. A batched environment takes in a batched set of actions and returns a batched set of observations. This means for all numpy arrays in the input and output nested structures, the first dimension is the batch size. When batched, the leftmost dimension is not part of the action_spec or the observation_spec and corresponds to the batch dimension. When batched and handle_auto_reset, it checks `np.all(steps.is_last())`."},"document":{"kind":"string","value":"def batched(self) -> bool:\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def batch_size(self) -> Optional[int]:\n if self.batched:\n raise RuntimeError(\n 'Environment %s marked itself as batched but did not override the '\n 'batch_size property'\n % type(self)\n )\n return None","def is_batch():\n\n pass","def _global_batch_size(self):\n return True","def has_full_batch(self) -> bool:","def should_handle_all_batches(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"should_handle_all_batches\")","def batching_enabled(self) -> bool:\n ...","def has_batch(self) -> bool:\n return self._buffer and (self._batch_size is None or sum(\n BlockAccessor.for_block(b).num_rows()\n for b in self._buffer) >= self._batch_size)","def dispatch_one_batch(self, iterator):\n\n if self._aborting:\n return False\n\n batch_size = self._get_batch_size()\n\n with self._lock:\n # to ensure an even distribution of the workload between workers,\n # we look ahead in the original iterators more than batch_size\n # tasks - However, we keep consuming only one batch at each\n # dispatch_one_batch call. The extra tasks are stored in a local\n # queue, _ready_batches, that is looked-up prior to re-consuming\n # tasks from the origal iterator.\n try:\n tasks = self._ready_batches.get(block=False)\n except queue.Empty:\n # slice the iterator n_jobs * batchsize items at a time. If the\n # slice returns less than that, then the current batchsize puts\n # too much weight on a subset of workers, while other may end\n # up starving. So in this case, re-scale the batch size\n # accordingly to distribute evenly the last items between all\n # workers.\n n_jobs = self._cached_effective_n_jobs\n big_batch_size = batch_size * n_jobs\n\n islice = list(itertools.islice(iterator, big_batch_size))\n if len(islice) == 0:\n return False\n elif (iterator is self._original_iterator and\n len(islice) < big_batch_size):\n # We reached the end of the original iterator (unless\n # iterator is the ``pre_dispatch``-long initial slice of\n # the original iterator) -- decrease the batch size to\n # account for potential variance in the batches running\n # time.\n final_batch_size = max(1, len(islice) // (10 * n_jobs))\n else:\n final_batch_size = max(1, len(islice) // n_jobs)\n\n # enqueue n_jobs batches in a local queue\n for i in range(0, len(islice), final_batch_size):\n tasks = BatchedCalls(islice[i:i + final_batch_size],\n self._backend.get_nested_backend(),\n self._reducer_callback,\n self._pickle_cache)\n self._ready_batches.put(tasks)\n\n # finally, get one task.\n tasks = self._ready_batches.get(block=False)\n if len(tasks) == 0:\n # No more tasks available in the iterator: tell caller to stop.\n return False\n else:\n self._dispatch(tasks)\n return True","def batch_size(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_size\")","def isFull(self):\n if len(self.batch) == self.__batch_size:\n return True\n return False","def get_evaluation_batch_size():\n return 1","def batch(self):\n return self._batch","def _batch(self, batch_size):\n transform_or_spec = self._specs.get(\n 'transform_or_spec', self.transform_or_spec)\n if hasattr(transform_or_spec, '_batch'):\n transform_or_spec = transform_or_spec._batch(batch_size)\n return _DeferredTensorSpec(\n self._get_batched_input_spec(batch_size),\n transform_or_spec=transform_or_spec,\n dtype=self.dtype,\n shape=(None if self.shape is None\n else tf.TensorShape([batch_size]).concatenate(self.shape)),\n name=self.name,\n also_track_spec=self._also_track_spec)","def _implements_predict_batch_hooks(self):\n return not is_default(self.on_predict_batch_begin) or not is_default(\n self.on_predict_batch_end\n )","def batch_size(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"batch_size\")","def _implements_train_batch_hooks(self):\n return not is_default(self.on_train_batch_begin) or not is_default(\n self.on_train_batch_end\n )","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def compute_batch(self, duplicate_manager=None,context_manager=None):\n from ...acquisitions import AcquisitionTS\n assert isinstance(self.acquisition, AcquisitionTS)\n \n X_batch,_ = self.acquisition.optimize()\n k=1\n \n # --- GET the remaining elements\n while k<self.batch_size:\n new_sample,_ = self.acquisition.optimize()\n X_batch = np.vstack((X_batch,new_sample))\n k +=1\n \n return X_batch","def batch_size(self) -> int:\n ...","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n if self._batch_size is not None:\n return self._batch_size # custom batch size defined\n if self.task == 'objdet':\n return 8\n annos_per_img = self._annos_per_img[self.dataset]\n if self.task in {'predcls', 'sgcls'}:\n annos_per_img = annos_per_img['pairs']\n elif self.task == 'objcls':\n annos_per_img = annos_per_img['objects']\n elif self.task == 'preddet' and self.filter_multiple_preds:\n annos_per_img = annos_per_img['predicates_filtered']\n elif self.task == 'preddet' and self.filter_duplicate_rels:\n annos_per_img = annos_per_img['duplicates_filtered']\n elif self.task in {'preddet', 'sggen'}:\n annos_per_img = annos_per_img['relations']\n batch_size = ceil(self._annotations_per_batch / annos_per_img)\n return max(batch_size, 2)","def _get_batch_size(self):\n if self.batch_size == 'auto':\n return self._backend.compute_batch_size()\n else:\n # Fixed batch size strategy\n return self.batch_size","def _assert_is_batched(self, *arrays):\n shape_list = []\n for array in arrays:\n if isinstance(array, tf.Tensor):\n shape_list.append(array.shape.as_list())\n else:\n shape_list.append(np.shape(array))\n # All arrays should have at least two dimensions.\n assert all([len(shape) >= 2 for shape in shape_list])\n # All arrays should have the same batch size.\n assert len(set([shape[0] for shape in shape_list])) == 1","def batch_size(self):\n return self.size","def process_state_batch(self, batch):\n # batch = np.squeeze(batch, axis=1)\n batch = np.array([np.concatenate(obs, axis=-1) for obs in batch])\n return batch","def _implements_test_batch_hooks(self):\n return not is_default(self.on_test_batch_begin) or not is_default(\n self.on_test_batch_end\n )","def compute_actions(\n self,\n observations: TensorStructType,\n state: Optional[List[TensorStructType]] = None,\n *,\n prev_action: Optional[TensorStructType] = None,\n prev_reward: Optional[TensorStructType] = None,\n info: Optional[EnvInfoDict] = None,\n policy_id: PolicyID = DEFAULT_POLICY_ID,\n full_fetch: bool = False,\n explore: Optional[bool] = None,\n timestep: Optional[int] = None,\n episodes: Optional[List[Episode]] = None,\n unsquash_actions: Optional[bool] = None,\n clip_actions: Optional[bool] = None,\n **kwargs,\n ):\n # `unsquash_actions` is None: Use value of config['normalize_actions'].\n if unsquash_actions is None:\n unsquash_actions = self.config.normalize_actions\n # `clip_actions` is None: Use value of config['clip_actions'].\n elif clip_actions is None:\n clip_actions = self.config.clip_actions\n\n # Preprocess obs and states.\n state_defined = state is not None\n policy = self.get_policy(policy_id)\n filtered_obs, filtered_state = [], []\n for agent_id, ob in observations.items():\n worker = self.workers.local_worker()\n preprocessed = worker.preprocessors[policy_id].transform(ob)\n filtered = worker.filters[policy_id](preprocessed, update=False)\n filtered_obs.append(filtered)\n if state is None:\n continue\n elif agent_id in state:\n filtered_state.append(state[agent_id])\n else:\n filtered_state.append(policy.get_initial_state())\n\n # Batch obs and states\n obs_batch = np.stack(filtered_obs)\n if state is None:\n state = []\n else:\n state = list(zip(*filtered_state))\n state = [np.stack(s) for s in state]\n\n input_dict = {SampleBatch.OBS: obs_batch}\n\n # prev_action and prev_reward can be None, np.ndarray, or tensor-like structure.\n # Explicitly check for None here to avoid the error message \"The truth value of\n # an array with more than one element is ambiguous.\", when np arrays are passed\n # as arguments.\n if prev_action is not None:\n input_dict[SampleBatch.PREV_ACTIONS] = prev_action\n if prev_reward is not None:\n input_dict[SampleBatch.PREV_REWARDS] = prev_reward\n if info:\n input_dict[SampleBatch.INFOS] = info\n for i, s in enumerate(state):\n input_dict[f\"state_in_{i}\"] = s\n\n # Batch compute actions\n actions, states, infos = policy.compute_actions_from_input_dict(\n input_dict=input_dict,\n explore=explore,\n timestep=timestep,\n episodes=episodes,\n )\n\n # Unbatch actions for the environment into a multi-agent dict.\n single_actions = space_utils.unbatch(actions)\n actions = {}\n for key, a in zip(observations, single_actions):\n # If we work in normalized action space (normalize_actions=True),\n # we re-translate here into the env's action space.\n if unsquash_actions:\n a = space_utils.unsquash_action(a, policy.action_space_struct)\n # Clip, according to env's action space.\n elif clip_actions:\n a = space_utils.clip_action(a, policy.action_space_struct)\n actions[key] = a\n\n # Unbatch states into a multi-agent dict.\n unbatched_states = {}\n for idx, agent_id in enumerate(observations):\n unbatched_states[agent_id] = [s[idx] for s in states]\n\n # Return only actions or full tuple\n if state_defined or full_fetch:\n return actions, unbatched_states, infos\n else:\n return actions","def batch_shape(self) -> torch.Size:\n self._check_if_fitted()\n return torch.Size([self.num_mcmc_samples])","def get_batch_size():\n return get_global_variable(GraphKeys.BATCH_SIZE)","def batch_split(self) -> np.array:\n pass","def get_batch(self):\n return self.batch","def enable_batched_operations(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"enable_batched_operations\")","def batch_actions(self):\n return self.resource.model.batch_actions","def num_batches(self):\n\t\t\n\t\treturn len(self.batch_stats)","def BatchConfig(**kwargs):\n return _validate(_BatchConfig(**kwargs))","def has_next_batch(self):\n return self.current_index + self.batch_size <= self.count","def hook_store_batch_size(module):\n if self._batch_size == {}:\n batch_axis = 0\n batch_size = module.input0.shape[batch_axis]\n\n for group in param_groups:\n group_id = id(group)\n\n if self._verbose:\n print(f\"Group {group_id}: Store 'batch_size'\")\n\n self._batch_size[group_id] = batch_size","def backend_is_buffered(cls):\n return bool(cls._buffer_context)","def batch_request_size(self):\n return self._batch_request_size","def process_batch(self, batch):\n # shapes are [time, ...original dims...]\n v_global = np.stack(batch[:,0]) # [time, agents, l_state_one_agent]\n # note that *_local objects have shape\n # [time, agents, ...original dim...]\n obs_others = np.stack(batch[:,1]) # [time,agents,h,w,c] or [time, agents, obs_others]\n v_local = np.stack(batch[:,2]) # [time,agents,l]\n actions = np.stack(batch[:,3]) # [time,agents]\n reward = np.stack(batch[:,4]) # [time]\n reward_local = np.stack(batch[:,5]) # [time,agents]\n v_global_next = np.stack(batch[:,6]) # [time, agents, l_state_one_agent]\n obs_others_next = np.stack(batch[:,7]) # [time,agents,h,w,c]\n v_local_next = np.stack(batch[:,8]) # [time,agents,l]\n done = np.stack(batch[:,9]) # [time]\n goals = np.stack(batch[:,10]) # [time, agents, l_goal]\n\n batch = None\n \n n_steps = v_global.shape[0]\n \n # For all global quantities, for each time step,\n # duplicate values <n_agents> times for\n # batch processing of all agents\n reward = np.repeat(reward, self.n_agents, axis=0)\n\n # In-place reshape for *_local quantities,\n # so that one time step for one agent is considered\n # one batch entry\n if self.experiment == 'sumo':\n obs_others.shape = (n_steps*self.n_agents, self.h_obs,\n self.w_obs, self.c_obs)\n obs_others_next.shape = (n_steps*self.n_agents, self.h_obs,\n self.w_obs, self.c_obs)\n elif self.experiment == 'particle':\n obs_others.shape = (n_steps*self.n_agents, self.l_obs_others)\n obs_others_next.shape = (n_steps*self.n_agents, self.l_obs_others)\n v_local.shape = (n_steps*self.n_agents, self.l_obs)\n reward_local.shape = (n_steps*self.n_agents)\n v_local_next.shape = (n_steps*self.n_agents, self.l_obs)\n\n actions_1hot, actions_others_1hot = self.process_actions(n_steps, actions)\n \n return n_steps, v_global, obs_others, v_local, actions_1hot, actions_others_1hot, reward, reward_local, v_global_next, obs_others_next, v_local_next, done, goals","def get_batch(self) -> CBInput:\n sample_batch_idx, batch_arms = self.gen_arms_per_batch()\n context_arm_features = self.gen_features_batch(batch_idx=sample_batch_idx)\n assert context_arm_features.ndim == 3\n rewards_all_arms = self.features_to_rewards(\n inp_feature=context_arm_features, sample_batch_idx=sample_batch_idx\n )\n batch = CBInput(\n context_arm_features=context_arm_features,\n arms=batch_arms, # ads of batch_size campaigns\n rewards_all_arms=rewards_all_arms,\n )\n return batch","def process_state_batch(self, batch):\n return np.squeeze(batch, axis=1)","def batch_size(self):\n return self._first_rgb.shape[0]","def batch_size(self):\n self.validate_shape_and_dtype()\n return self.rgb.shape[0]","def get_batch_actions(self, states, greedy=False):\n with self._policy.G._session.as_default():\n return self._policy.policy.predict(\n self._policy.get_session(),\n states, greedy)","def __len__(self):\n return len(self.batches)","def eval_batch_size(sess=None):\n return eval_global_variable(GraphKeys.BATCH_SIZE, sess)","def batch_size(self) -> ConfigNodePropertyInteger:\n return self._batch_size","def get_batch_runs(self):\n return self.batch_runs","def record_batch_size(self):\n return 10000","def observe_np(\n state: np.ndarray,\n impulse: np.ndarray,\n):\n state_shape = state.shape\n if len(state_shape) < 3:\n raise ValueError(\n \"State must be at least 3D (`[width, height, channel]`) but got {}\"\n \"\".format(state.shape))\n\n state_shape = [-1 if dim is None else dim for dim in state_shape]\n\n # State now has single batch dimension, has shape\n # `[batch_size, height, width, channel]`.\n state = np.reshape(state, [-1] + state_shape[-3:])\n\n state = numpy_convolution.convolve_2d(state, impulse, padding=\"SAME\")\n\n # Retrieve original `batch_dimensions`.\n return np.reshape(state, state_shape[:-1] + [impulse.shape[-1]])","def in_memory(self) -> bool:\n return all(isinstance(x, np.ndarray) for x in self.chunks.values())","def _update_num_batches(self):\n # maximum possible number of batches is equal to number of whole times\n # batch_size divides in to the number of data points which can be\n # found using integer division\n possible_num_batches = self.inputs.shape[0] // self.batch_size\n if self.max_num_batches == -1:\n self.num_batches = possible_num_batches\n else:\n self.num_batches = min(self.max_num_batches, possible_num_batches)","def active_observation_shape(self):\n # if isinstance(self._env.observation_space, spaces.Box) and len(self._env.observation_space.shape) > 1:\n # return np.prod(self._env.observation_space.spaces[key].shape)\n\n if not isinstance(self._env.observation_space, spaces.Dict):\n return super(GymAdapter, self).active_observation_shape\n\n observation_keys = (\n self.observation_keys\n or list(self._env.observation_space.spaces.keys()))\n\n active_size = sum(\n np.prod(self._env.observation_space.spaces[key].shape)\n for key in observation_keys)\n\n active_observation_shape = (active_size, )\n return active_observation_shape","def _maybe_do_batch(\n self,\n accumulator: _CombinerStatsGeneratorsCombineFnAcc,\n force: bool = False) -> None:\n if self._should_do_batch(accumulator, force):\n self._combine_batch_size.update(accumulator.curr_batch_size)\n self._combine_byte_size.update(accumulator.curr_byte_size)\n if len(accumulator.input_record_batches) == 1:\n record_batch = accumulator.input_record_batches[0]\n else:\n record_batch = table_util.MergeRecordBatches(\n accumulator.input_record_batches)\n accumulator.partial_accumulators = self._for_each_generator(\n lambda gen, gen_acc: gen.add_input(gen_acc, record_batch),\n accumulator.partial_accumulators)\n del accumulator.input_record_batches[:]\n accumulator.curr_batch_size = 0\n accumulator.curr_byte_size = 0","def on_batch_mode(self, event):\n if self.parent is not None:\n wx.PostEvent(self.parent,\n NewBatchEvent(enable=True))","def batch(ctx, config, job_number, total_jobs, executor, force_overwrite):\n # Imports inside CLI for speed\n from yatsm.utils import distribute_jobs\n\n # TODO: remove when not debugging\n import dask\n dask.set_options(get=dask.async.get_sync)\n\n\n # TODO: Better define how authoritative reader when using multiple datasets\n # and choosing block shape (in config?)\n # TODO: Allow user to specify block shape in config (?)\n block_windows = config.primary_reader.block_windows\n job_idx = distribute_jobs(job_number, total_jobs, len(block_windows))\n\n logger.debug('Working on {} of {} block windows'\n .format(len(job_idx), len(block_windows)))\n\n block_windows = [block_windows[i] for i in job_idx]\n\n force_overwrite = (force_overwrite or\n config['pipeline'].get('overwrite', False))\n\n # TODO: iterate over block_windows assigned to ``job_id``\n futures = {}\n for idx, window in block_windows:\n future = executor.submit(batch_block,\n config=config,\n readers=config.readers,\n window=window,\n overwrite=force_overwrite)\n futures[future] = window\n\n n_good, n_skip, n_fail = 0, 0, 0\n for future in executor.as_completed(futures):\n window = futures[future]\n try:\n result = future.result()\n if isinstance(result, str):\n logger.info(\"Wrote to: %s\" % result)\n n_good += 1\n else:\n n_skip += 1\n time.sleep(1)\n except KeyboardInterrupt:\n logger.critical('Interrupting and shutting down')\n executor.shutdown()\n raise click.Abort()\n except Exception:\n logger.exception(\"Exception for window: {}\".format(window))\n n_fail += 1\n raise # TODO: remove and log?\n\n logger.info('Complete: %s' % n_good)\n logger.info('Skipped: %s' % n_skip)\n logger.info('Failed: %s' % n_fail)","def get_eval_batch(self) -> jnp.ndarray:\n\n return self.dataset[-self.eval_batch_size:, ...]","def get_batch(self, batch_size, batch_length):\n with tf.device(self._device):\n min_size = tf.reduce_min(self._current_size)\n tf.Assert(min_size >= batch_length, [\n \"Not all environments has enough data. The smallest data \"\n \"size is: \", min_size, \"Try storing more data before \"\n \"calling get_batch\"\n ])\n\n batch_size_per_env = batch_size // self._num_envs\n remaining = batch_size % self._num_envs\n if batch_size_per_env > 0:\n env_ids = tf.tile(\n tf.range(self._num_envs, dtype=tf.int64),\n [batch_size_per_env])\n else:\n env_ids = tf.zeros((0, ), tf.int64)\n if remaining > 0:\n eids = tf.range(self._num_envs, dtype=tf.int64)\n eids = tf.random.shuffle(eids)[:remaining]\n env_ids = tf.concat([env_ids, eids], axis=0)\n\n r = tf.random.uniform(tf.shape(env_ids))\n num_positions = self._current_size - batch_length + 1\n num_positions = tf.gather(num_positions, env_ids)\n pos = tf.cast(r * tf.cast(num_positions, tf.float32), tf.int64)\n pos += tf.gather(self._current_pos - self._current_size, env_ids)\n pos = tf.reshape(pos, [-1, 1]) # [B, 1]\n pos = pos + tf.expand_dims(\n tf.range(batch_length, dtype=tf.int64), axis=0) # [B, T]\n pos = pos % self._max_length\n pos = tf.expand_dims(pos, -1) # [B, T, 1]\n env_ids = tf.reshape(env_ids, [-1, 1]) # [B, 1]\n env_ids = tf.tile(env_ids, [1, batch_length]) # [B, T]\n env_ids = tf.reshape(env_ids, [-1, batch_length, 1]) # [B, T, 1]\n indices = tf.concat([env_ids, pos], axis=-1) # [B, T, 2]\n return tf.nest.map_structure(\n lambda buffer: tf.gather_nd(buffer, indices), self._buffer)","def add(\n self,\n batch: RolloutBatchProtocol,\n buffer_ids: Optional[Union[np.ndarray, list[int]]] = None,\n ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\n # preprocess batch\n new_batch = Batch()\n for key in set(self._reserved_keys).intersection(batch.keys()):\n new_batch.__dict__[key] = batch[key]\n batch = new_batch\n batch.__dict__[\"done\"] = np.logical_or(batch.terminated, batch.truncated)\n assert {\"obs\", \"act\", \"rew\", \"terminated\", \"truncated\", \"done\"}.issubset(batch.keys())\n if self._save_only_last_obs:\n batch.obs = batch.obs[:, -1]\n if not self._save_obs_next:\n batch.pop(\"obs_next\", None)\n elif self._save_only_last_obs:\n batch.obs_next = batch.obs_next[:, -1]\n # get index\n if buffer_ids is None:\n buffer_ids = np.arange(self.buffer_num)\n ptrs, ep_lens, ep_rews, ep_idxs = [], [], [], []\n for batch_idx, buffer_id in enumerate(buffer_ids):\n ptr, ep_rew, ep_len, ep_idx = self.buffers[buffer_id]._add_index(\n batch.rew[batch_idx],\n batch.done[batch_idx],\n )\n ptrs.append(ptr + self._offset[buffer_id])\n ep_lens.append(ep_len)\n ep_rews.append(ep_rew)\n ep_idxs.append(ep_idx + self._offset[buffer_id])\n self.last_index[buffer_id] = ptr + self._offset[buffer_id]\n self._lengths[buffer_id] = len(self.buffers[buffer_id])\n ptrs = np.array(ptrs)\n try:\n self._meta[ptrs] = batch\n except ValueError:\n batch.rew = batch.rew.astype(float)\n batch.done = batch.done.astype(bool)\n batch.terminated = batch.terminated.astype(bool)\n batch.truncated = batch.truncated.astype(bool)\n if self._meta.is_empty():\n self._meta = create_value(batch, self.maxsize, stack=False) # type: ignore\n else: # dynamic key pops up in batch\n alloc_by_keys_diff(self._meta, batch, self.maxsize, False)\n self._set_batch_for_children()\n self._meta[ptrs] = batch\n return ptrs, np.array(ep_rews), np.array(ep_lens), np.array(ep_idxs)","def can_sample(self, batch_size):\n return batch_size + 1 <= self.num_in_buffer","def get_global_batch_size(self) -> int:\n return self._global_batch_size","def is_ready_update(self):\n size_of_buffer = len(self.training_buffer.update_buffer['actions'])\n return size_of_buffer > max(int(self.trainer_parameters['buffer_size'] / self.policy.sequence_length), 1)","def batch_len(batch):\n flatlist, _ = tree_util.tree_flatten(batch)\n if len(flatlist) < 1:\n return 0\n b = flatlist[0].shape[0]\n assert all(\n arr.shape[0] == b for arr in flatlist if th.is_tensor(arr)\n ), \"Not all arrays have same batchsize!\"\n return b","def _create_batch_list(self):\n return [None] * self.bufsize","def init_batch(self):\n pass","def collect_batch(self, observation):\n observations, actions, rewards, dones = [observation], [], [], []\n for _ in range(self.rollout_len):\n action = self.act(observation)\n observation, reward, done = self.env_pool.step(action)\n observations.append(observation)\n actions.append(action)\n rewards.append(reward)\n dones.append(done)\n return observations, actions, rewards, dones","def _is_buffered(self):\n return self.buffered or type(self)._buffer_context","def _get_batched_input_spec(self, batch_size):\n if isinstance(self._input_spec, type_spec.BatchableTypeSpec):\n return self._input_spec._batch(batch_size) # pylint: disable=protected-access\n if isinstance(self._input_spec, resource_variable_ops.VariableSpec):\n return resource_variable_ops.VariableSpec(\n shape=tf.TensorShape([batch_size]).concatenate(\n self._input_spec.shape),\n dtype=self._input_spec.dtype,\n trainable=self._input_spec.trainable)\n raise NotImplementedError(\n f'`{self.value_type.__name__}`s `TypeSpec` is not supported for '\n f'inputs of type {type(self._input_spec)}.')","def gather_all(self):\n size = tf.reduce_min(self._current_size)\n max_size = tf.reduce_max(self._current_size)\n tf.Assert(size == max_size, [\n \"Not all environment have the same size. min_size:\", size,\n \"max_size:\", max_size\n ])\n\n if size == self._max_length:\n return tf.nest.map_structure(lambda buf: buf.value(), self._buffer)\n else:\n return tf.nest.map_structure(lambda buf: buf[:, :size, ...],\n self._buffer)","def sample_batch(models, env_constructor, device, config):\n\n # Initialize envs.\n envs = [SubProcessWrapper(env_constructor) for _ in range(config[\"SAMPLE_PARALLEL_ENVS\"])]\n\n player_ids = list(models.keys())\n\n # EpisodeData for in-progress episodes.\n # ep_datas[i][p_id] references the EpisodeData for player p_id in the i'th env.\n ep_datas = [{p_id: None for p_id in player_ids} for _ in envs]\n\n # actions[i][p_id] references the action for player p_id in the i'th env.\n actions = [{p_id: None for p_id in player_ids} for _ in envs]\n\n num_steps = {p_id: 0 for p_id in player_ids}\n\n # final_ep_datas[p_id][i] references the EpisodeData for the i'th episode collected for player p_id.\n final_ep_datas = {p_id: [] for p_id in player_ids}\n\n # While at least one player is below SAMPLE_MIN_NUM_STEPS.\n while np.any(np.array([n for n in num_steps.values()]) < config[\"SAMPLE_MIN_NUM_STEPS\"]):\n # 1. Step all envs asynchronously.\n\n # Keep a record of which envs were 'reset' and which were 'stepped' so that we\n # know what return values to expect when we receive the results asynchronously.\n env_was_reset = []\n for i_env, env in enumerate(envs):\n if not env.call_sync(\"is_in_progress\"):\n env_was_reset.append(True)\n for p_id in player_ids:\n ep_data = ep_datas[i_env][p_id]\n # If this is not the very first iteration, then save the episode.\n if ep_data is not None:\n # Drop the last observation, as we never acted on it.\n ep_data.observations = ep_data.observations[:len(ep_data.rewards)]\n final_ep_datas[p_id].append(ep_data)\n num_steps[p_id] += len(ep_data.rewards)\n ep_datas[i_env] = {p_id: EpisodeData() for p_id in player_ids}\n env.call_async(\"reset\")\n else:\n env_was_reset.append(False)\n actions = {p_id: ep_datas[i_env][p_id].actions[-1] for p_id in player_ids}\n env.call_async(\"step\", actions)\n\n # 2. Receive results from async env steps.\n\n for i_env, env in enumerate(envs):\n if env_was_reset[i_env]:\n obs = env.get_result()\n for p_id in player_ids:\n ep_datas[i_env][p_id].observations.append(obs[p_id])\n else:\n obs, rewards, dones, step_infos = env.get_result()\n for p_id in player_ids:\n ep_data = ep_datas[i_env][p_id]\n ep_data.observations.append(obs[p_id])\n ep_data.rewards.append(rewards[p_id])\n # step_infos entry should already exist for this step.\n ep_data.step_info[-1].update(step_infos[p_id])\n\n # 3. Sample actions.\n\n player_id_to_state_batch = {p_id: [] for p_id in player_ids}\n for i_env, env in enumerate(envs):\n for p_id in player_ids:\n player_id_to_state_batch[p_id].append(ep_datas[i_env][p_id].observations[-1])\n\n for p_id in player_ids:\n model = models[p_id]\n with torch.no_grad():\n state_batch = np.array(player_id_to_state_batch[p_id])\n state_batch = torch.Tensor(state_batch)\n state_batch = state_batch.to(device)\n ship_act_logits, shipyard_act_logits, value_preds = model(state_batch)\n\n ship_action_dist, shipyard_action_dist = model.get_action_distribution(\n ship_act_logits, shipyard_act_logits, state_batch)\n\n ship_action = ship_action_dist.sample()\n shipyard_action = shipyard_action_dist.sample()\n ship_act_entropy = ship_action_dist.entropy()\n shipyard_act_entropy = shipyard_action_dist.entropy()\n\n action_log_prob = model.action_log_prob(\n ship_action_dist,\n shipyard_action_dist,\n ship_action,\n shipyard_action,\n )\n\n ship_action = ship_action.cpu().detach().numpy()\n shipyard_action = shipyard_action.cpu().detach().numpy()\n action_log_prob = action_log_prob.cpu().detach().numpy()\n value_preds = value_preds.cpu().detach().numpy()\n ship_act_entropy = ship_act_entropy.cpu().detach().numpy()\n shipyard_act_entropy = shipyard_act_entropy.cpu().detach().numpy()\n\n for i_env, env in enumerate(envs):\n if env.call_sync(\"is_in_progress\"):\n ep_data = ep_datas[i_env][p_id]\n ep_data.actions.append((\n ship_action[i_env, ...],\n shipyard_action[i_env, ...],\n ))\n ep_data.act_log_probs.append(action_log_prob[i_env])\n ep_data.value_preds.append(value_preds[i_env])\n # Create step_info entry with info for step that hasn't happend (in env) yet.\n ep_data.step_info.append(\n {\n \"ship_action_dist_entropy\": ship_act_entropy[i_env],\n \"shipyard_action_dist_entropy\": shipyard_act_entropy[i_env],\n }\n )\n\n # Close all envs\n for e in envs:\n e.close()\n\n return final_ep_datas","def train_batch(self, batch_info: BatchInfo) -> None:\n # Each DQN batch is\n # 1. Roll out environment and store out experience in the buffer\n self.model.eval()\n\n # Helper variables for rollouts\n episode_information = []\n frames = 0\n\n with torch.no_grad():\n if not self.env_roller.is_ready_for_sampling():\n while not self.env_roller.is_ready_for_sampling():\n rollout = self.env_roller.rollout(batch_info, self.model)\n\n episode_information.extend(rollout.episode_information())\n frames += rollout.frames()\n else:\n for i in range(self.settings.batch_rollout_rounds):\n rollout = self.env_roller.rollout(batch_info, self.model)\n\n episode_information.extend(rollout.episode_information())\n frames += rollout.frames()\n\n batch_info['frames'] = frames\n batch_info['episode_infos'] = episode_information\n\n # 2. Sample the buffer and train the algo on sample batch\n self.model.train()\n\n # Algo will aggregate data into this list:\n batch_info['sub_batch_data'] = []\n\n for i in range(self.settings.batch_training_rounds):\n sampled_rollout = self.env_roller.sample(batch_info, self.model)\n\n batch_result = self.algo.optimizer_step(\n batch_info=batch_info,\n device=self.device,\n model=self.model,\n rollout=sampled_rollout\n )\n\n self.env_roller.update(rollout=sampled_rollout, batch_info=batch_result)\n\n batch_info['sub_batch_data'].append(batch_result)\n\n batch_info.aggregate_key('sub_batch_data')","def acq_batch_size(self):\n return self.batch_size * self.batches_per_acquisition","def run_batch(self):\n\n print(\"Running experiment with batch_size {}...\".format(self.batch_size))\n\n errors = self.W.new_tensor([])\n energies = self.W.new_tensor([])\n\n x = (2 * self.W.new(self.N, self.batch_size).random_(2) - 1).float() # Initialize the x vector\n rands = self.W.new(self.t_max, self.batch_size).uniform_() # The random values which will be compared to the acceptance probabilities\n idxs = self.W.new(self.t_max, self.batch_size).random_(self.N).long() # The indices which will be flipped in x at each iteration\n\n energy, wx = utils.compute_energy_batch(x, self.W, self.Y) # Compute the initial value of the energy\n\n for iteration in range(self.t_max):\n self.beta_scheduler.step(energies) # Update the value of beta according to the cooling strategy\n\n x, energy, wx = self.chain.step_batch(x, self.W, self.Y, self.beta_scheduler.beta, energy, wx, idxs[iteration], rands[iteration])\n energies = torch.cat((energies, energy.unsqueeze(0)))\n\n e = utils.compute_reconstruction_error_batch(x, self.X) # Compute the current reconstruction error\n errors = torch.cat((errors, e.unsqueeze(0)))\n\n return errors, energies, x","def application_enabled(namespace):\n client = get_mgmt_service_client(BatchManagementClient)\n acc = client.batch_account.get(namespace.resource_group, namespace.account_name)\n if not acc:\n raise ValueError(\"Batch account '{}' not found.\".format(namespace.account_name))\n if not acc.auto_storage or not acc.auto_storage.storage_account_id: # pylint: disable=no-member\n raise ValueError(\"Batch account '{}' needs auto-storage enabled.\".\n format(namespace.account_name))","def batch_compute_environment(self):\n return self._get_output(\"BatchComputeEnvironmentArn\")","def is_ready_update(self):\n size_of_buffer = len(self.training_buffer.update_buffer[\"actions\"])\n return size_of_buffer > max(\n int(self.trainer_parameters[\"buffer_size\"] / self.policy.sequence_length), 1\n )","def expand(self, batch_shape):\n batch_shape = list(batch_shape)\n if len(batch_shape) < len(self.batch_shape):\n raise ValueError(\"Expected len(batch_shape) >= len(self.batch_shape), \"\n \"actual {} vs {}\".format(len(batch_shape), len(self.batch_shape)))\n # check sizes of existing dims\n for dim in range(-1, -1 - len(self.batch_shape), -1):\n if batch_shape[dim] == -1:\n batch_shape[dim] = self.batch_shape[dim]\n elif batch_shape[dim] != self.batch_shape[dim]:\n if self.batch_shape[dim] != 1:\n raise ValueError(\"Cannot broadcast dim {} of size {} to size {}\".format(\n dim, self.batch_shape[dim], batch_shape[dim]))\n else:\n raise NotImplementedError(\"https://github.com/uber/pyro/issues/1119\")\n sample_shape = batch_shape[:len(batch_shape) - len(self.batch_shape)]\n return self.expand_by(sample_shape)","def batch_node_count(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_node_count\")","def ExpectedMaxBatchSizes(self, run_params):\n return self.max_batch_sizes","def obs_action_shape(env):\n obs_space = env.observation_space\n return np.append(np.ravel(obs_space.high)+1, [env.action_space.n])","def process_batch(self, batch):\n # extend with current batch\n self._extend(batch)\n\n # unpack and compute bounds\n length = len(self.obs)\n c = self.c\n\n # normally we cannot compute samples for the last c elements, but\n # in the terminal case, we halluciante values where necessary\n end = length if batch.terminal else length - c\n\n # collect samples to return in a FeudalBatch\n feudal_batch = FeudalBatch()\n for t in range(c, end):\n\n # state difference\n s_diff = self.s[t + c] - self.s[t]\n\n # intrinsic reward\n ri = 0\n # note that this for loop considers s and g values\n # 1 timestep to c timesteps (inclusively) ago\n for i in range(1, c + 1):\n ri_s_diff = self.s[t] - self.s[t - i]\n if np.linalg.norm(ri_s_diff) != 0:\n ri += cosine_similarity(ri_s_diff, self.g[t - i])\n ri /= c\n\n # sum of g values used to derive w, input to the linear transform\n gsum = np.zeros_like(self.g[t - c])\n for i in range(t - c, t + 1):\n gsum += self.g[i]\n\n # add to the batch\n feudal_batch.add(self.obs[t], self.a[t], self.returns[t], s_diff,\n ri, gsum, self.features[t])\n\n # in the terminal case, set reset flag\n if batch.terminal:\n self.last_terminal = True\n # in the general case, forget all but the last 2 * c elements\n # reason being that the first c of those we have already computed\n # a batch for, and the second c need those first c\n else:\n twoc = 2 * self.c\n self.obs = self.obs[-twoc:]\n self.a = self.a[-twoc:]\n self.returns = self.returns[-twoc:]\n self.s = self.s[-twoc:]\n self.g = self.g[-twoc:]\n self.features = self.features[-twoc:]\n\n return feudal_batch.get_batch()","def is_buffer_empty(self): \n if self.buffer.shape == (0, 5):\n return True\n else:\n return False","def valid_minibatches(self):\n batch_size = self.params['batch_size']\n start_index = 0\n while start_index + batch_size < 500:\n end_index = start_index + batch_size\n yield self.input[start_index:end_index], self.y[start_index:end_index]\n start_index = end_index","def observationsMatchingBatchDim(self):\n ret = []\n for inp in range(len(self._observations)):\n all_obs = self._observations[inp].getSlice(0)\n processed = all_obs\n # If we have more than 1 observation per state\n if self._batch_dimensions[inp][0] > 1 and len(all_obs) > 0:\n obs_per_state = self._batch_dimensions[inp][0]\n processed = np.zeros((len(all_obs), obs_per_state, ) + all_obs.shape[1:])\n # for every observation, we create a state\n for i in range(all_obs.shape[0]):\n state = np.zeros((obs_per_state,) + all_obs.shape[1:])\n # everything before state_start_idx is all_obs[0]\n state_start_idx = 0\n\n # start index in all_obs\n start_idx = i - obs_per_state\n\n # if we're in the first obs_per_state observations, we need to fill the first\n # -start_idx elements with all_obs[0]\n if start_idx < 0:\n n_to_fill = -start_idx\n state[0:n_to_fill] = np.repeat(all_obs[0][None, :, :], n_to_fill, axis=0)\n\n # start of where to fill the rest\n state_start_idx = n_to_fill\n\n # new start_idx for\n start_idx = 0\n state[state_start_idx:] = all_obs[start_idx+1:i+1]\n processed[i] = state\n\n ret.append(processed)\n return ret","def evaluate_agent(self, batch_size=None):\n if batch_size is None:\n batch_size = self.minibatch_size\n\n i_test = 0\n i_comp = 0\n test_scores = []\n batch_scores = [0]*batch_size\n\n test_envs = np.array([None]*batch_size)\n obs_batch = []\n\n for i in range(len(self.test_envs)):\n test_env = self.test_envs[i]\n obs = test_env.reset()\n score = 0.0\n while True:\n action = self.predict(torch.FloatTensor(obs).to(self.device),\n test_env.reversible_spins)\n obs, rew, done, info = test_env.step(action)\n score += rew\n if done:\n test_scores.append(score)\n break\n\n '''\n while i_comp < self.test_episodes:\n\n for i, env in enumerate(test_envs):\n if env is None and i_test < self.test_episodes:\n test_env, testing_in_reversible_spin_env = self.get_random_env(self.test_envs)\n obs = test_env.reset()\n test_env = deepcopy(test_env)\n\n test_envs[i] = test_env\n obs_batch.append(obs)\n\n i_test += 1\n\n actions = self.predict(torch.FloatTensor(np.array(obs_batch)).to(self.device),\n testing_in_reversible_spin_env)\n\n obs_batch = []\n\n i = 0\n for env, action in zip(test_envs, actions):\n\n if env is not None:\n obs, rew, done, info = env.step(action)\n\n if self.test_metric == TestMetric.CUMULATIVE_REWARD:\n batch_scores[i] += rew\n\n if done:\n if self.test_metric == TestMetric.BEST_ENERGY:\n batch_scores[i] = env.best_energy\n elif self.test_metric == TestMetric.ENERGY_ERROR:\n batch_scores[i] = abs(env.best_energy - env.calculate_best()[0])\n elif self.test_metric == TestMetric.MAX_CUT:\n batch_scores[i] = env.get_best_cut()\n elif self.test_metric == TestMetric.FINAL_CUT:\n batch_scores[i] = env.calculate_cut()\n\n test_scores.append(batch_scores[i])\n\n if self.test_metric == TestMetric.CUMULATIVE_REWARD:\n batch_scores[i] = 0\n\n i_comp += 1\n test_envs[i] = None\n else:\n obs_batch.append(obs)\n\n i += 1\n\n if self.test_metric == TestMetric.ENERGY_ERROR:\n print(\"\\n{}/{} graphs solved optimally\".format(np.count_nonzero(np.array(test_scores)==0),self.test_episodes), end=\"\")\n '''\n print(test_scores)\n return np.mean(test_scores)","def on_predict_batch_begin(self, step, logs=None):","def action_dimension(self):\n return self.env.action_spec[0].shape[0]","def test_minibatches(self):\n batch_size = self.params['batch_size']\n start_index = 0\n while start_index + batch_size < 500:\n end_index = start_index + batch_size\n yield self.input[start_index:end_index], self.y[start_index:end_index]\n start_index = end_index","def next_batch(self):\n # Whether an epoch is done.\n done = False\n samples = []\n for _ in range(self.batch_size):\n # Indeed, `>` will not occur.\n if self.ptr >= self.dataset_size:\n done = True\n break\n else:\n self.ptr += 1\n sample = self.enqueuer.queue.get()\n samples.append(sample)\n # print 'queue size: {}'.format(self.enqueuer.queue.qsize())\n # Indeed, `>` will not occur.\n if self.ptr >= self.dataset_size:\n done = True\n return samples, done","def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\n return self._values.get('max_batching_window')","def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\n return self._values.get('max_batching_window')","def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\n return self._values.get('max_batching_window')","def train_dynamic(batch_size=10):\n \n return"],"string":"[\n \"def batch_size(self) -> Optional[int]:\\n if self.batched:\\n raise RuntimeError(\\n 'Environment %s marked itself as batched but did not override the '\\n 'batch_size property'\\n % type(self)\\n )\\n return None\",\n \"def is_batch():\\n\\n pass\",\n \"def _global_batch_size(self):\\n return True\",\n \"def has_full_batch(self) -> bool:\",\n \"def should_handle_all_batches(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"should_handle_all_batches\\\")\",\n \"def batching_enabled(self) -> bool:\\n ...\",\n \"def has_batch(self) -> bool:\\n return self._buffer and (self._batch_size is None or sum(\\n BlockAccessor.for_block(b).num_rows()\\n for b in self._buffer) >= self._batch_size)\",\n \"def dispatch_one_batch(self, iterator):\\n\\n if self._aborting:\\n return False\\n\\n batch_size = self._get_batch_size()\\n\\n with self._lock:\\n # to ensure an even distribution of the workload between workers,\\n # we look ahead in the original iterators more than batch_size\\n # tasks - However, we keep consuming only one batch at each\\n # dispatch_one_batch call. The extra tasks are stored in a local\\n # queue, _ready_batches, that is looked-up prior to re-consuming\\n # tasks from the origal iterator.\\n try:\\n tasks = self._ready_batches.get(block=False)\\n except queue.Empty:\\n # slice the iterator n_jobs * batchsize items at a time. If the\\n # slice returns less than that, then the current batchsize puts\\n # too much weight on a subset of workers, while other may end\\n # up starving. So in this case, re-scale the batch size\\n # accordingly to distribute evenly the last items between all\\n # workers.\\n n_jobs = self._cached_effective_n_jobs\\n big_batch_size = batch_size * n_jobs\\n\\n islice = list(itertools.islice(iterator, big_batch_size))\\n if len(islice) == 0:\\n return False\\n elif (iterator is self._original_iterator and\\n len(islice) < big_batch_size):\\n # We reached the end of the original iterator (unless\\n # iterator is the ``pre_dispatch``-long initial slice of\\n # the original iterator) -- decrease the batch size to\\n # account for potential variance in the batches running\\n # time.\\n final_batch_size = max(1, len(islice) // (10 * n_jobs))\\n else:\\n final_batch_size = max(1, len(islice) // n_jobs)\\n\\n # enqueue n_jobs batches in a local queue\\n for i in range(0, len(islice), final_batch_size):\\n tasks = BatchedCalls(islice[i:i + final_batch_size],\\n self._backend.get_nested_backend(),\\n self._reducer_callback,\\n self._pickle_cache)\\n self._ready_batches.put(tasks)\\n\\n # finally, get one task.\\n tasks = self._ready_batches.get(block=False)\\n if len(tasks) == 0:\\n # No more tasks available in the iterator: tell caller to stop.\\n return False\\n else:\\n self._dispatch(tasks)\\n return True\",\n \"def batch_size(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_size\\\")\",\n \"def isFull(self):\\n if len(self.batch) == self.__batch_size:\\n return True\\n return False\",\n \"def get_evaluation_batch_size():\\n return 1\",\n \"def batch(self):\\n return self._batch\",\n \"def _batch(self, batch_size):\\n transform_or_spec = self._specs.get(\\n 'transform_or_spec', self.transform_or_spec)\\n if hasattr(transform_or_spec, '_batch'):\\n transform_or_spec = transform_or_spec._batch(batch_size)\\n return _DeferredTensorSpec(\\n self._get_batched_input_spec(batch_size),\\n transform_or_spec=transform_or_spec,\\n dtype=self.dtype,\\n shape=(None if self.shape is None\\n else tf.TensorShape([batch_size]).concatenate(self.shape)),\\n name=self.name,\\n also_track_spec=self._also_track_spec)\",\n \"def _implements_predict_batch_hooks(self):\\n return not is_default(self.on_predict_batch_begin) or not is_default(\\n self.on_predict_batch_end\\n )\",\n \"def batch_size(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"batch_size\\\")\",\n \"def _implements_train_batch_hooks(self):\\n return not is_default(self.on_train_batch_begin) or not is_default(\\n self.on_train_batch_end\\n )\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def compute_batch(self, duplicate_manager=None,context_manager=None):\\n from ...acquisitions import AcquisitionTS\\n assert isinstance(self.acquisition, AcquisitionTS)\\n \\n X_batch,_ = self.acquisition.optimize()\\n k=1\\n \\n # --- GET the remaining elements\\n while k<self.batch_size:\\n new_sample,_ = self.acquisition.optimize()\\n X_batch = np.vstack((X_batch,new_sample))\\n k +=1\\n \\n return X_batch\",\n \"def batch_size(self) -> int:\\n ...\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n if self._batch_size is not None:\\n return self._batch_size # custom batch size defined\\n if self.task == 'objdet':\\n return 8\\n annos_per_img = self._annos_per_img[self.dataset]\\n if self.task in {'predcls', 'sgcls'}:\\n annos_per_img = annos_per_img['pairs']\\n elif self.task == 'objcls':\\n annos_per_img = annos_per_img['objects']\\n elif self.task == 'preddet' and self.filter_multiple_preds:\\n annos_per_img = annos_per_img['predicates_filtered']\\n elif self.task == 'preddet' and self.filter_duplicate_rels:\\n annos_per_img = annos_per_img['duplicates_filtered']\\n elif self.task in {'preddet', 'sggen'}:\\n annos_per_img = annos_per_img['relations']\\n batch_size = ceil(self._annotations_per_batch / annos_per_img)\\n return max(batch_size, 2)\",\n \"def _get_batch_size(self):\\n if self.batch_size == 'auto':\\n return self._backend.compute_batch_size()\\n else:\\n # Fixed batch size strategy\\n return self.batch_size\",\n \"def _assert_is_batched(self, *arrays):\\n shape_list = []\\n for array in arrays:\\n if isinstance(array, tf.Tensor):\\n shape_list.append(array.shape.as_list())\\n else:\\n shape_list.append(np.shape(array))\\n # All arrays should have at least two dimensions.\\n assert all([len(shape) >= 2 for shape in shape_list])\\n # All arrays should have the same batch size.\\n assert len(set([shape[0] for shape in shape_list])) == 1\",\n \"def batch_size(self):\\n return self.size\",\n \"def process_state_batch(self, batch):\\n # batch = np.squeeze(batch, axis=1)\\n batch = np.array([np.concatenate(obs, axis=-1) for obs in batch])\\n return batch\",\n \"def _implements_test_batch_hooks(self):\\n return not is_default(self.on_test_batch_begin) or not is_default(\\n self.on_test_batch_end\\n )\",\n \"def compute_actions(\\n self,\\n observations: TensorStructType,\\n state: Optional[List[TensorStructType]] = None,\\n *,\\n prev_action: Optional[TensorStructType] = None,\\n prev_reward: Optional[TensorStructType] = None,\\n info: Optional[EnvInfoDict] = None,\\n policy_id: PolicyID = DEFAULT_POLICY_ID,\\n full_fetch: bool = False,\\n explore: Optional[bool] = None,\\n timestep: Optional[int] = None,\\n episodes: Optional[List[Episode]] = None,\\n unsquash_actions: Optional[bool] = None,\\n clip_actions: Optional[bool] = None,\\n **kwargs,\\n ):\\n # `unsquash_actions` is None: Use value of config['normalize_actions'].\\n if unsquash_actions is None:\\n unsquash_actions = self.config.normalize_actions\\n # `clip_actions` is None: Use value of config['clip_actions'].\\n elif clip_actions is None:\\n clip_actions = self.config.clip_actions\\n\\n # Preprocess obs and states.\\n state_defined = state is not None\\n policy = self.get_policy(policy_id)\\n filtered_obs, filtered_state = [], []\\n for agent_id, ob in observations.items():\\n worker = self.workers.local_worker()\\n preprocessed = worker.preprocessors[policy_id].transform(ob)\\n filtered = worker.filters[policy_id](preprocessed, update=False)\\n filtered_obs.append(filtered)\\n if state is None:\\n continue\\n elif agent_id in state:\\n filtered_state.append(state[agent_id])\\n else:\\n filtered_state.append(policy.get_initial_state())\\n\\n # Batch obs and states\\n obs_batch = np.stack(filtered_obs)\\n if state is None:\\n state = []\\n else:\\n state = list(zip(*filtered_state))\\n state = [np.stack(s) for s in state]\\n\\n input_dict = {SampleBatch.OBS: obs_batch}\\n\\n # prev_action and prev_reward can be None, np.ndarray, or tensor-like structure.\\n # Explicitly check for None here to avoid the error message \\\"The truth value of\\n # an array with more than one element is ambiguous.\\\", when np arrays are passed\\n # as arguments.\\n if prev_action is not None:\\n input_dict[SampleBatch.PREV_ACTIONS] = prev_action\\n if prev_reward is not None:\\n input_dict[SampleBatch.PREV_REWARDS] = prev_reward\\n if info:\\n input_dict[SampleBatch.INFOS] = info\\n for i, s in enumerate(state):\\n input_dict[f\\\"state_in_{i}\\\"] = s\\n\\n # Batch compute actions\\n actions, states, infos = policy.compute_actions_from_input_dict(\\n input_dict=input_dict,\\n explore=explore,\\n timestep=timestep,\\n episodes=episodes,\\n )\\n\\n # Unbatch actions for the environment into a multi-agent dict.\\n single_actions = space_utils.unbatch(actions)\\n actions = {}\\n for key, a in zip(observations, single_actions):\\n # If we work in normalized action space (normalize_actions=True),\\n # we re-translate here into the env's action space.\\n if unsquash_actions:\\n a = space_utils.unsquash_action(a, policy.action_space_struct)\\n # Clip, according to env's action space.\\n elif clip_actions:\\n a = space_utils.clip_action(a, policy.action_space_struct)\\n actions[key] = a\\n\\n # Unbatch states into a multi-agent dict.\\n unbatched_states = {}\\n for idx, agent_id in enumerate(observations):\\n unbatched_states[agent_id] = [s[idx] for s in states]\\n\\n # Return only actions or full tuple\\n if state_defined or full_fetch:\\n return actions, unbatched_states, infos\\n else:\\n return actions\",\n \"def batch_shape(self) -> torch.Size:\\n self._check_if_fitted()\\n return torch.Size([self.num_mcmc_samples])\",\n \"def get_batch_size():\\n return get_global_variable(GraphKeys.BATCH_SIZE)\",\n \"def batch_split(self) -> np.array:\\n pass\",\n \"def get_batch(self):\\n return self.batch\",\n \"def enable_batched_operations(self) -> pulumi.Output[Optional[bool]]:\\n return pulumi.get(self, \\\"enable_batched_operations\\\")\",\n \"def batch_actions(self):\\n return self.resource.model.batch_actions\",\n \"def num_batches(self):\\n\\t\\t\\n\\t\\treturn len(self.batch_stats)\",\n \"def BatchConfig(**kwargs):\\n return _validate(_BatchConfig(**kwargs))\",\n \"def has_next_batch(self):\\n return self.current_index + self.batch_size <= self.count\",\n \"def hook_store_batch_size(module):\\n if self._batch_size == {}:\\n batch_axis = 0\\n batch_size = module.input0.shape[batch_axis]\\n\\n for group in param_groups:\\n group_id = id(group)\\n\\n if self._verbose:\\n print(f\\\"Group {group_id}: Store 'batch_size'\\\")\\n\\n self._batch_size[group_id] = batch_size\",\n \"def backend_is_buffered(cls):\\n return bool(cls._buffer_context)\",\n \"def batch_request_size(self):\\n return self._batch_request_size\",\n \"def process_batch(self, batch):\\n # shapes are [time, ...original dims...]\\n v_global = np.stack(batch[:,0]) # [time, agents, l_state_one_agent]\\n # note that *_local objects have shape\\n # [time, agents, ...original dim...]\\n obs_others = np.stack(batch[:,1]) # [time,agents,h,w,c] or [time, agents, obs_others]\\n v_local = np.stack(batch[:,2]) # [time,agents,l]\\n actions = np.stack(batch[:,3]) # [time,agents]\\n reward = np.stack(batch[:,4]) # [time]\\n reward_local = np.stack(batch[:,5]) # [time,agents]\\n v_global_next = np.stack(batch[:,6]) # [time, agents, l_state_one_agent]\\n obs_others_next = np.stack(batch[:,7]) # [time,agents,h,w,c]\\n v_local_next = np.stack(batch[:,8]) # [time,agents,l]\\n done = np.stack(batch[:,9]) # [time]\\n goals = np.stack(batch[:,10]) # [time, agents, l_goal]\\n\\n batch = None\\n \\n n_steps = v_global.shape[0]\\n \\n # For all global quantities, for each time step,\\n # duplicate values <n_agents> times for\\n # batch processing of all agents\\n reward = np.repeat(reward, self.n_agents, axis=0)\\n\\n # In-place reshape for *_local quantities,\\n # so that one time step for one agent is considered\\n # one batch entry\\n if self.experiment == 'sumo':\\n obs_others.shape = (n_steps*self.n_agents, self.h_obs,\\n self.w_obs, self.c_obs)\\n obs_others_next.shape = (n_steps*self.n_agents, self.h_obs,\\n self.w_obs, self.c_obs)\\n elif self.experiment == 'particle':\\n obs_others.shape = (n_steps*self.n_agents, self.l_obs_others)\\n obs_others_next.shape = (n_steps*self.n_agents, self.l_obs_others)\\n v_local.shape = (n_steps*self.n_agents, self.l_obs)\\n reward_local.shape = (n_steps*self.n_agents)\\n v_local_next.shape = (n_steps*self.n_agents, self.l_obs)\\n\\n actions_1hot, actions_others_1hot = self.process_actions(n_steps, actions)\\n \\n return n_steps, v_global, obs_others, v_local, actions_1hot, actions_others_1hot, reward, reward_local, v_global_next, obs_others_next, v_local_next, done, goals\",\n \"def get_batch(self) -> CBInput:\\n sample_batch_idx, batch_arms = self.gen_arms_per_batch()\\n context_arm_features = self.gen_features_batch(batch_idx=sample_batch_idx)\\n assert context_arm_features.ndim == 3\\n rewards_all_arms = self.features_to_rewards(\\n inp_feature=context_arm_features, sample_batch_idx=sample_batch_idx\\n )\\n batch = CBInput(\\n context_arm_features=context_arm_features,\\n arms=batch_arms, # ads of batch_size campaigns\\n rewards_all_arms=rewards_all_arms,\\n )\\n return batch\",\n \"def process_state_batch(self, batch):\\n return np.squeeze(batch, axis=1)\",\n \"def batch_size(self):\\n return self._first_rgb.shape[0]\",\n \"def batch_size(self):\\n self.validate_shape_and_dtype()\\n return self.rgb.shape[0]\",\n \"def get_batch_actions(self, states, greedy=False):\\n with self._policy.G._session.as_default():\\n return self._policy.policy.predict(\\n self._policy.get_session(),\\n states, greedy)\",\n \"def __len__(self):\\n return len(self.batches)\",\n \"def eval_batch_size(sess=None):\\n return eval_global_variable(GraphKeys.BATCH_SIZE, sess)\",\n \"def batch_size(self) -> ConfigNodePropertyInteger:\\n return self._batch_size\",\n \"def get_batch_runs(self):\\n return self.batch_runs\",\n \"def record_batch_size(self):\\n return 10000\",\n \"def observe_np(\\n state: np.ndarray,\\n impulse: np.ndarray,\\n):\\n state_shape = state.shape\\n if len(state_shape) < 3:\\n raise ValueError(\\n \\\"State must be at least 3D (`[width, height, channel]`) but got {}\\\"\\n \\\"\\\".format(state.shape))\\n\\n state_shape = [-1 if dim is None else dim for dim in state_shape]\\n\\n # State now has single batch dimension, has shape\\n # `[batch_size, height, width, channel]`.\\n state = np.reshape(state, [-1] + state_shape[-3:])\\n\\n state = numpy_convolution.convolve_2d(state, impulse, padding=\\\"SAME\\\")\\n\\n # Retrieve original `batch_dimensions`.\\n return np.reshape(state, state_shape[:-1] + [impulse.shape[-1]])\",\n \"def in_memory(self) -> bool:\\n return all(isinstance(x, np.ndarray) for x in self.chunks.values())\",\n \"def _update_num_batches(self):\\n # maximum possible number of batches is equal to number of whole times\\n # batch_size divides in to the number of data points which can be\\n # found using integer division\\n possible_num_batches = self.inputs.shape[0] // self.batch_size\\n if self.max_num_batches == -1:\\n self.num_batches = possible_num_batches\\n else:\\n self.num_batches = min(self.max_num_batches, possible_num_batches)\",\n \"def active_observation_shape(self):\\n # if isinstance(self._env.observation_space, spaces.Box) and len(self._env.observation_space.shape) > 1:\\n # return np.prod(self._env.observation_space.spaces[key].shape)\\n\\n if not isinstance(self._env.observation_space, spaces.Dict):\\n return super(GymAdapter, self).active_observation_shape\\n\\n observation_keys = (\\n self.observation_keys\\n or list(self._env.observation_space.spaces.keys()))\\n\\n active_size = sum(\\n np.prod(self._env.observation_space.spaces[key].shape)\\n for key in observation_keys)\\n\\n active_observation_shape = (active_size, )\\n return active_observation_shape\",\n \"def _maybe_do_batch(\\n self,\\n accumulator: _CombinerStatsGeneratorsCombineFnAcc,\\n force: bool = False) -> None:\\n if self._should_do_batch(accumulator, force):\\n self._combine_batch_size.update(accumulator.curr_batch_size)\\n self._combine_byte_size.update(accumulator.curr_byte_size)\\n if len(accumulator.input_record_batches) == 1:\\n record_batch = accumulator.input_record_batches[0]\\n else:\\n record_batch = table_util.MergeRecordBatches(\\n accumulator.input_record_batches)\\n accumulator.partial_accumulators = self._for_each_generator(\\n lambda gen, gen_acc: gen.add_input(gen_acc, record_batch),\\n accumulator.partial_accumulators)\\n del accumulator.input_record_batches[:]\\n accumulator.curr_batch_size = 0\\n accumulator.curr_byte_size = 0\",\n \"def on_batch_mode(self, event):\\n if self.parent is not None:\\n wx.PostEvent(self.parent,\\n NewBatchEvent(enable=True))\",\n \"def batch(ctx, config, job_number, total_jobs, executor, force_overwrite):\\n # Imports inside CLI for speed\\n from yatsm.utils import distribute_jobs\\n\\n # TODO: remove when not debugging\\n import dask\\n dask.set_options(get=dask.async.get_sync)\\n\\n\\n # TODO: Better define how authoritative reader when using multiple datasets\\n # and choosing block shape (in config?)\\n # TODO: Allow user to specify block shape in config (?)\\n block_windows = config.primary_reader.block_windows\\n job_idx = distribute_jobs(job_number, total_jobs, len(block_windows))\\n\\n logger.debug('Working on {} of {} block windows'\\n .format(len(job_idx), len(block_windows)))\\n\\n block_windows = [block_windows[i] for i in job_idx]\\n\\n force_overwrite = (force_overwrite or\\n config['pipeline'].get('overwrite', False))\\n\\n # TODO: iterate over block_windows assigned to ``job_id``\\n futures = {}\\n for idx, window in block_windows:\\n future = executor.submit(batch_block,\\n config=config,\\n readers=config.readers,\\n window=window,\\n overwrite=force_overwrite)\\n futures[future] = window\\n\\n n_good, n_skip, n_fail = 0, 0, 0\\n for future in executor.as_completed(futures):\\n window = futures[future]\\n try:\\n result = future.result()\\n if isinstance(result, str):\\n logger.info(\\\"Wrote to: %s\\\" % result)\\n n_good += 1\\n else:\\n n_skip += 1\\n time.sleep(1)\\n except KeyboardInterrupt:\\n logger.critical('Interrupting and shutting down')\\n executor.shutdown()\\n raise click.Abort()\\n except Exception:\\n logger.exception(\\\"Exception for window: {}\\\".format(window))\\n n_fail += 1\\n raise # TODO: remove and log?\\n\\n logger.info('Complete: %s' % n_good)\\n logger.info('Skipped: %s' % n_skip)\\n logger.info('Failed: %s' % n_fail)\",\n \"def get_eval_batch(self) -> jnp.ndarray:\\n\\n return self.dataset[-self.eval_batch_size:, ...]\",\n \"def get_batch(self, batch_size, batch_length):\\n with tf.device(self._device):\\n min_size = tf.reduce_min(self._current_size)\\n tf.Assert(min_size >= batch_length, [\\n \\\"Not all environments has enough data. The smallest data \\\"\\n \\\"size is: \\\", min_size, \\\"Try storing more data before \\\"\\n \\\"calling get_batch\\\"\\n ])\\n\\n batch_size_per_env = batch_size // self._num_envs\\n remaining = batch_size % self._num_envs\\n if batch_size_per_env > 0:\\n env_ids = tf.tile(\\n tf.range(self._num_envs, dtype=tf.int64),\\n [batch_size_per_env])\\n else:\\n env_ids = tf.zeros((0, ), tf.int64)\\n if remaining > 0:\\n eids = tf.range(self._num_envs, dtype=tf.int64)\\n eids = tf.random.shuffle(eids)[:remaining]\\n env_ids = tf.concat([env_ids, eids], axis=0)\\n\\n r = tf.random.uniform(tf.shape(env_ids))\\n num_positions = self._current_size - batch_length + 1\\n num_positions = tf.gather(num_positions, env_ids)\\n pos = tf.cast(r * tf.cast(num_positions, tf.float32), tf.int64)\\n pos += tf.gather(self._current_pos - self._current_size, env_ids)\\n pos = tf.reshape(pos, [-1, 1]) # [B, 1]\\n pos = pos + tf.expand_dims(\\n tf.range(batch_length, dtype=tf.int64), axis=0) # [B, T]\\n pos = pos % self._max_length\\n pos = tf.expand_dims(pos, -1) # [B, T, 1]\\n env_ids = tf.reshape(env_ids, [-1, 1]) # [B, 1]\\n env_ids = tf.tile(env_ids, [1, batch_length]) # [B, T]\\n env_ids = tf.reshape(env_ids, [-1, batch_length, 1]) # [B, T, 1]\\n indices = tf.concat([env_ids, pos], axis=-1) # [B, T, 2]\\n return tf.nest.map_structure(\\n lambda buffer: tf.gather_nd(buffer, indices), self._buffer)\",\n \"def add(\\n self,\\n batch: RolloutBatchProtocol,\\n buffer_ids: Optional[Union[np.ndarray, list[int]]] = None,\\n ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\\n # preprocess batch\\n new_batch = Batch()\\n for key in set(self._reserved_keys).intersection(batch.keys()):\\n new_batch.__dict__[key] = batch[key]\\n batch = new_batch\\n batch.__dict__[\\\"done\\\"] = np.logical_or(batch.terminated, batch.truncated)\\n assert {\\\"obs\\\", \\\"act\\\", \\\"rew\\\", \\\"terminated\\\", \\\"truncated\\\", \\\"done\\\"}.issubset(batch.keys())\\n if self._save_only_last_obs:\\n batch.obs = batch.obs[:, -1]\\n if not self._save_obs_next:\\n batch.pop(\\\"obs_next\\\", None)\\n elif self._save_only_last_obs:\\n batch.obs_next = batch.obs_next[:, -1]\\n # get index\\n if buffer_ids is None:\\n buffer_ids = np.arange(self.buffer_num)\\n ptrs, ep_lens, ep_rews, ep_idxs = [], [], [], []\\n for batch_idx, buffer_id in enumerate(buffer_ids):\\n ptr, ep_rew, ep_len, ep_idx = self.buffers[buffer_id]._add_index(\\n batch.rew[batch_idx],\\n batch.done[batch_idx],\\n )\\n ptrs.append(ptr + self._offset[buffer_id])\\n ep_lens.append(ep_len)\\n ep_rews.append(ep_rew)\\n ep_idxs.append(ep_idx + self._offset[buffer_id])\\n self.last_index[buffer_id] = ptr + self._offset[buffer_id]\\n self._lengths[buffer_id] = len(self.buffers[buffer_id])\\n ptrs = np.array(ptrs)\\n try:\\n self._meta[ptrs] = batch\\n except ValueError:\\n batch.rew = batch.rew.astype(float)\\n batch.done = batch.done.astype(bool)\\n batch.terminated = batch.terminated.astype(bool)\\n batch.truncated = batch.truncated.astype(bool)\\n if self._meta.is_empty():\\n self._meta = create_value(batch, self.maxsize, stack=False) # type: ignore\\n else: # dynamic key pops up in batch\\n alloc_by_keys_diff(self._meta, batch, self.maxsize, False)\\n self._set_batch_for_children()\\n self._meta[ptrs] = batch\\n return ptrs, np.array(ep_rews), np.array(ep_lens), np.array(ep_idxs)\",\n \"def can_sample(self, batch_size):\\n return batch_size + 1 <= self.num_in_buffer\",\n \"def get_global_batch_size(self) -> int:\\n return self._global_batch_size\",\n \"def is_ready_update(self):\\n size_of_buffer = len(self.training_buffer.update_buffer['actions'])\\n return size_of_buffer > max(int(self.trainer_parameters['buffer_size'] / self.policy.sequence_length), 1)\",\n \"def batch_len(batch):\\n flatlist, _ = tree_util.tree_flatten(batch)\\n if len(flatlist) < 1:\\n return 0\\n b = flatlist[0].shape[0]\\n assert all(\\n arr.shape[0] == b for arr in flatlist if th.is_tensor(arr)\\n ), \\\"Not all arrays have same batchsize!\\\"\\n return b\",\n \"def _create_batch_list(self):\\n return [None] * self.bufsize\",\n \"def init_batch(self):\\n pass\",\n \"def collect_batch(self, observation):\\n observations, actions, rewards, dones = [observation], [], [], []\\n for _ in range(self.rollout_len):\\n action = self.act(observation)\\n observation, reward, done = self.env_pool.step(action)\\n observations.append(observation)\\n actions.append(action)\\n rewards.append(reward)\\n dones.append(done)\\n return observations, actions, rewards, dones\",\n \"def _is_buffered(self):\\n return self.buffered or type(self)._buffer_context\",\n \"def _get_batched_input_spec(self, batch_size):\\n if isinstance(self._input_spec, type_spec.BatchableTypeSpec):\\n return self._input_spec._batch(batch_size) # pylint: disable=protected-access\\n if isinstance(self._input_spec, resource_variable_ops.VariableSpec):\\n return resource_variable_ops.VariableSpec(\\n shape=tf.TensorShape([batch_size]).concatenate(\\n self._input_spec.shape),\\n dtype=self._input_spec.dtype,\\n trainable=self._input_spec.trainable)\\n raise NotImplementedError(\\n f'`{self.value_type.__name__}`s `TypeSpec` is not supported for '\\n f'inputs of type {type(self._input_spec)}.')\",\n \"def gather_all(self):\\n size = tf.reduce_min(self._current_size)\\n max_size = tf.reduce_max(self._current_size)\\n tf.Assert(size == max_size, [\\n \\\"Not all environment have the same size. min_size:\\\", size,\\n \\\"max_size:\\\", max_size\\n ])\\n\\n if size == self._max_length:\\n return tf.nest.map_structure(lambda buf: buf.value(), self._buffer)\\n else:\\n return tf.nest.map_structure(lambda buf: buf[:, :size, ...],\\n self._buffer)\",\n \"def sample_batch(models, env_constructor, device, config):\\n\\n # Initialize envs.\\n envs = [SubProcessWrapper(env_constructor) for _ in range(config[\\\"SAMPLE_PARALLEL_ENVS\\\"])]\\n\\n player_ids = list(models.keys())\\n\\n # EpisodeData for in-progress episodes.\\n # ep_datas[i][p_id] references the EpisodeData for player p_id in the i'th env.\\n ep_datas = [{p_id: None for p_id in player_ids} for _ in envs]\\n\\n # actions[i][p_id] references the action for player p_id in the i'th env.\\n actions = [{p_id: None for p_id in player_ids} for _ in envs]\\n\\n num_steps = {p_id: 0 for p_id in player_ids}\\n\\n # final_ep_datas[p_id][i] references the EpisodeData for the i'th episode collected for player p_id.\\n final_ep_datas = {p_id: [] for p_id in player_ids}\\n\\n # While at least one player is below SAMPLE_MIN_NUM_STEPS.\\n while np.any(np.array([n for n in num_steps.values()]) < config[\\\"SAMPLE_MIN_NUM_STEPS\\\"]):\\n # 1. Step all envs asynchronously.\\n\\n # Keep a record of which envs were 'reset' and which were 'stepped' so that we\\n # know what return values to expect when we receive the results asynchronously.\\n env_was_reset = []\\n for i_env, env in enumerate(envs):\\n if not env.call_sync(\\\"is_in_progress\\\"):\\n env_was_reset.append(True)\\n for p_id in player_ids:\\n ep_data = ep_datas[i_env][p_id]\\n # If this is not the very first iteration, then save the episode.\\n if ep_data is not None:\\n # Drop the last observation, as we never acted on it.\\n ep_data.observations = ep_data.observations[:len(ep_data.rewards)]\\n final_ep_datas[p_id].append(ep_data)\\n num_steps[p_id] += len(ep_data.rewards)\\n ep_datas[i_env] = {p_id: EpisodeData() for p_id in player_ids}\\n env.call_async(\\\"reset\\\")\\n else:\\n env_was_reset.append(False)\\n actions = {p_id: ep_datas[i_env][p_id].actions[-1] for p_id in player_ids}\\n env.call_async(\\\"step\\\", actions)\\n\\n # 2. Receive results from async env steps.\\n\\n for i_env, env in enumerate(envs):\\n if env_was_reset[i_env]:\\n obs = env.get_result()\\n for p_id in player_ids:\\n ep_datas[i_env][p_id].observations.append(obs[p_id])\\n else:\\n obs, rewards, dones, step_infos = env.get_result()\\n for p_id in player_ids:\\n ep_data = ep_datas[i_env][p_id]\\n ep_data.observations.append(obs[p_id])\\n ep_data.rewards.append(rewards[p_id])\\n # step_infos entry should already exist for this step.\\n ep_data.step_info[-1].update(step_infos[p_id])\\n\\n # 3. Sample actions.\\n\\n player_id_to_state_batch = {p_id: [] for p_id in player_ids}\\n for i_env, env in enumerate(envs):\\n for p_id in player_ids:\\n player_id_to_state_batch[p_id].append(ep_datas[i_env][p_id].observations[-1])\\n\\n for p_id in player_ids:\\n model = models[p_id]\\n with torch.no_grad():\\n state_batch = np.array(player_id_to_state_batch[p_id])\\n state_batch = torch.Tensor(state_batch)\\n state_batch = state_batch.to(device)\\n ship_act_logits, shipyard_act_logits, value_preds = model(state_batch)\\n\\n ship_action_dist, shipyard_action_dist = model.get_action_distribution(\\n ship_act_logits, shipyard_act_logits, state_batch)\\n\\n ship_action = ship_action_dist.sample()\\n shipyard_action = shipyard_action_dist.sample()\\n ship_act_entropy = ship_action_dist.entropy()\\n shipyard_act_entropy = shipyard_action_dist.entropy()\\n\\n action_log_prob = model.action_log_prob(\\n ship_action_dist,\\n shipyard_action_dist,\\n ship_action,\\n shipyard_action,\\n )\\n\\n ship_action = ship_action.cpu().detach().numpy()\\n shipyard_action = shipyard_action.cpu().detach().numpy()\\n action_log_prob = action_log_prob.cpu().detach().numpy()\\n value_preds = value_preds.cpu().detach().numpy()\\n ship_act_entropy = ship_act_entropy.cpu().detach().numpy()\\n shipyard_act_entropy = shipyard_act_entropy.cpu().detach().numpy()\\n\\n for i_env, env in enumerate(envs):\\n if env.call_sync(\\\"is_in_progress\\\"):\\n ep_data = ep_datas[i_env][p_id]\\n ep_data.actions.append((\\n ship_action[i_env, ...],\\n shipyard_action[i_env, ...],\\n ))\\n ep_data.act_log_probs.append(action_log_prob[i_env])\\n ep_data.value_preds.append(value_preds[i_env])\\n # Create step_info entry with info for step that hasn't happend (in env) yet.\\n ep_data.step_info.append(\\n {\\n \\\"ship_action_dist_entropy\\\": ship_act_entropy[i_env],\\n \\\"shipyard_action_dist_entropy\\\": shipyard_act_entropy[i_env],\\n }\\n )\\n\\n # Close all envs\\n for e in envs:\\n e.close()\\n\\n return final_ep_datas\",\n \"def train_batch(self, batch_info: BatchInfo) -> None:\\n # Each DQN batch is\\n # 1. Roll out environment and store out experience in the buffer\\n self.model.eval()\\n\\n # Helper variables for rollouts\\n episode_information = []\\n frames = 0\\n\\n with torch.no_grad():\\n if not self.env_roller.is_ready_for_sampling():\\n while not self.env_roller.is_ready_for_sampling():\\n rollout = self.env_roller.rollout(batch_info, self.model)\\n\\n episode_information.extend(rollout.episode_information())\\n frames += rollout.frames()\\n else:\\n for i in range(self.settings.batch_rollout_rounds):\\n rollout = self.env_roller.rollout(batch_info, self.model)\\n\\n episode_information.extend(rollout.episode_information())\\n frames += rollout.frames()\\n\\n batch_info['frames'] = frames\\n batch_info['episode_infos'] = episode_information\\n\\n # 2. Sample the buffer and train the algo on sample batch\\n self.model.train()\\n\\n # Algo will aggregate data into this list:\\n batch_info['sub_batch_data'] = []\\n\\n for i in range(self.settings.batch_training_rounds):\\n sampled_rollout = self.env_roller.sample(batch_info, self.model)\\n\\n batch_result = self.algo.optimizer_step(\\n batch_info=batch_info,\\n device=self.device,\\n model=self.model,\\n rollout=sampled_rollout\\n )\\n\\n self.env_roller.update(rollout=sampled_rollout, batch_info=batch_result)\\n\\n batch_info['sub_batch_data'].append(batch_result)\\n\\n batch_info.aggregate_key('sub_batch_data')\",\n \"def acq_batch_size(self):\\n return self.batch_size * self.batches_per_acquisition\",\n \"def run_batch(self):\\n\\n print(\\\"Running experiment with batch_size {}...\\\".format(self.batch_size))\\n\\n errors = self.W.new_tensor([])\\n energies = self.W.new_tensor([])\\n\\n x = (2 * self.W.new(self.N, self.batch_size).random_(2) - 1).float() # Initialize the x vector\\n rands = self.W.new(self.t_max, self.batch_size).uniform_() # The random values which will be compared to the acceptance probabilities\\n idxs = self.W.new(self.t_max, self.batch_size).random_(self.N).long() # The indices which will be flipped in x at each iteration\\n\\n energy, wx = utils.compute_energy_batch(x, self.W, self.Y) # Compute the initial value of the energy\\n\\n for iteration in range(self.t_max):\\n self.beta_scheduler.step(energies) # Update the value of beta according to the cooling strategy\\n\\n x, energy, wx = self.chain.step_batch(x, self.W, self.Y, self.beta_scheduler.beta, energy, wx, idxs[iteration], rands[iteration])\\n energies = torch.cat((energies, energy.unsqueeze(0)))\\n\\n e = utils.compute_reconstruction_error_batch(x, self.X) # Compute the current reconstruction error\\n errors = torch.cat((errors, e.unsqueeze(0)))\\n\\n return errors, energies, x\",\n \"def application_enabled(namespace):\\n client = get_mgmt_service_client(BatchManagementClient)\\n acc = client.batch_account.get(namespace.resource_group, namespace.account_name)\\n if not acc:\\n raise ValueError(\\\"Batch account '{}' not found.\\\".format(namespace.account_name))\\n if not acc.auto_storage or not acc.auto_storage.storage_account_id: # pylint: disable=no-member\\n raise ValueError(\\\"Batch account '{}' needs auto-storage enabled.\\\".\\n format(namespace.account_name))\",\n \"def batch_compute_environment(self):\\n return self._get_output(\\\"BatchComputeEnvironmentArn\\\")\",\n \"def is_ready_update(self):\\n size_of_buffer = len(self.training_buffer.update_buffer[\\\"actions\\\"])\\n return size_of_buffer > max(\\n int(self.trainer_parameters[\\\"buffer_size\\\"] / self.policy.sequence_length), 1\\n )\",\n \"def expand(self, batch_shape):\\n batch_shape = list(batch_shape)\\n if len(batch_shape) < len(self.batch_shape):\\n raise ValueError(\\\"Expected len(batch_shape) >= len(self.batch_shape), \\\"\\n \\\"actual {} vs {}\\\".format(len(batch_shape), len(self.batch_shape)))\\n # check sizes of existing dims\\n for dim in range(-1, -1 - len(self.batch_shape), -1):\\n if batch_shape[dim] == -1:\\n batch_shape[dim] = self.batch_shape[dim]\\n elif batch_shape[dim] != self.batch_shape[dim]:\\n if self.batch_shape[dim] != 1:\\n raise ValueError(\\\"Cannot broadcast dim {} of size {} to size {}\\\".format(\\n dim, self.batch_shape[dim], batch_shape[dim]))\\n else:\\n raise NotImplementedError(\\\"https://github.com/uber/pyro/issues/1119\\\")\\n sample_shape = batch_shape[:len(batch_shape) - len(self.batch_shape)]\\n return self.expand_by(sample_shape)\",\n \"def batch_node_count(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_node_count\\\")\",\n \"def ExpectedMaxBatchSizes(self, run_params):\\n return self.max_batch_sizes\",\n \"def obs_action_shape(env):\\n obs_space = env.observation_space\\n return np.append(np.ravel(obs_space.high)+1, [env.action_space.n])\",\n \"def process_batch(self, batch):\\n # extend with current batch\\n self._extend(batch)\\n\\n # unpack and compute bounds\\n length = len(self.obs)\\n c = self.c\\n\\n # normally we cannot compute samples for the last c elements, but\\n # in the terminal case, we halluciante values where necessary\\n end = length if batch.terminal else length - c\\n\\n # collect samples to return in a FeudalBatch\\n feudal_batch = FeudalBatch()\\n for t in range(c, end):\\n\\n # state difference\\n s_diff = self.s[t + c] - self.s[t]\\n\\n # intrinsic reward\\n ri = 0\\n # note that this for loop considers s and g values\\n # 1 timestep to c timesteps (inclusively) ago\\n for i in range(1, c + 1):\\n ri_s_diff = self.s[t] - self.s[t - i]\\n if np.linalg.norm(ri_s_diff) != 0:\\n ri += cosine_similarity(ri_s_diff, self.g[t - i])\\n ri /= c\\n\\n # sum of g values used to derive w, input to the linear transform\\n gsum = np.zeros_like(self.g[t - c])\\n for i in range(t - c, t + 1):\\n gsum += self.g[i]\\n\\n # add to the batch\\n feudal_batch.add(self.obs[t], self.a[t], self.returns[t], s_diff,\\n ri, gsum, self.features[t])\\n\\n # in the terminal case, set reset flag\\n if batch.terminal:\\n self.last_terminal = True\\n # in the general case, forget all but the last 2 * c elements\\n # reason being that the first c of those we have already computed\\n # a batch for, and the second c need those first c\\n else:\\n twoc = 2 * self.c\\n self.obs = self.obs[-twoc:]\\n self.a = self.a[-twoc:]\\n self.returns = self.returns[-twoc:]\\n self.s = self.s[-twoc:]\\n self.g = self.g[-twoc:]\\n self.features = self.features[-twoc:]\\n\\n return feudal_batch.get_batch()\",\n \"def is_buffer_empty(self): \\n if self.buffer.shape == (0, 5):\\n return True\\n else:\\n return False\",\n \"def valid_minibatches(self):\\n batch_size = self.params['batch_size']\\n start_index = 0\\n while start_index + batch_size < 500:\\n end_index = start_index + batch_size\\n yield self.input[start_index:end_index], self.y[start_index:end_index]\\n start_index = end_index\",\n \"def observationsMatchingBatchDim(self):\\n ret = []\\n for inp in range(len(self._observations)):\\n all_obs = self._observations[inp].getSlice(0)\\n processed = all_obs\\n # If we have more than 1 observation per state\\n if self._batch_dimensions[inp][0] > 1 and len(all_obs) > 0:\\n obs_per_state = self._batch_dimensions[inp][0]\\n processed = np.zeros((len(all_obs), obs_per_state, ) + all_obs.shape[1:])\\n # for every observation, we create a state\\n for i in range(all_obs.shape[0]):\\n state = np.zeros((obs_per_state,) + all_obs.shape[1:])\\n # everything before state_start_idx is all_obs[0]\\n state_start_idx = 0\\n\\n # start index in all_obs\\n start_idx = i - obs_per_state\\n\\n # if we're in the first obs_per_state observations, we need to fill the first\\n # -start_idx elements with all_obs[0]\\n if start_idx < 0:\\n n_to_fill = -start_idx\\n state[0:n_to_fill] = np.repeat(all_obs[0][None, :, :], n_to_fill, axis=0)\\n\\n # start of where to fill the rest\\n state_start_idx = n_to_fill\\n\\n # new start_idx for\\n start_idx = 0\\n state[state_start_idx:] = all_obs[start_idx+1:i+1]\\n processed[i] = state\\n\\n ret.append(processed)\\n return ret\",\n \"def evaluate_agent(self, batch_size=None):\\n if batch_size is None:\\n batch_size = self.minibatch_size\\n\\n i_test = 0\\n i_comp = 0\\n test_scores = []\\n batch_scores = [0]*batch_size\\n\\n test_envs = np.array([None]*batch_size)\\n obs_batch = []\\n\\n for i in range(len(self.test_envs)):\\n test_env = self.test_envs[i]\\n obs = test_env.reset()\\n score = 0.0\\n while True:\\n action = self.predict(torch.FloatTensor(obs).to(self.device),\\n test_env.reversible_spins)\\n obs, rew, done, info = test_env.step(action)\\n score += rew\\n if done:\\n test_scores.append(score)\\n break\\n\\n '''\\n while i_comp < self.test_episodes:\\n\\n for i, env in enumerate(test_envs):\\n if env is None and i_test < self.test_episodes:\\n test_env, testing_in_reversible_spin_env = self.get_random_env(self.test_envs)\\n obs = test_env.reset()\\n test_env = deepcopy(test_env)\\n\\n test_envs[i] = test_env\\n obs_batch.append(obs)\\n\\n i_test += 1\\n\\n actions = self.predict(torch.FloatTensor(np.array(obs_batch)).to(self.device),\\n testing_in_reversible_spin_env)\\n\\n obs_batch = []\\n\\n i = 0\\n for env, action in zip(test_envs, actions):\\n\\n if env is not None:\\n obs, rew, done, info = env.step(action)\\n\\n if self.test_metric == TestMetric.CUMULATIVE_REWARD:\\n batch_scores[i] += rew\\n\\n if done:\\n if self.test_metric == TestMetric.BEST_ENERGY:\\n batch_scores[i] = env.best_energy\\n elif self.test_metric == TestMetric.ENERGY_ERROR:\\n batch_scores[i] = abs(env.best_energy - env.calculate_best()[0])\\n elif self.test_metric == TestMetric.MAX_CUT:\\n batch_scores[i] = env.get_best_cut()\\n elif self.test_metric == TestMetric.FINAL_CUT:\\n batch_scores[i] = env.calculate_cut()\\n\\n test_scores.append(batch_scores[i])\\n\\n if self.test_metric == TestMetric.CUMULATIVE_REWARD:\\n batch_scores[i] = 0\\n\\n i_comp += 1\\n test_envs[i] = None\\n else:\\n obs_batch.append(obs)\\n\\n i += 1\\n\\n if self.test_metric == TestMetric.ENERGY_ERROR:\\n print(\\\"\\\\n{}/{} graphs solved optimally\\\".format(np.count_nonzero(np.array(test_scores)==0),self.test_episodes), end=\\\"\\\")\\n '''\\n print(test_scores)\\n return np.mean(test_scores)\",\n \"def on_predict_batch_begin(self, step, logs=None):\",\n \"def action_dimension(self):\\n return self.env.action_spec[0].shape[0]\",\n \"def test_minibatches(self):\\n batch_size = self.params['batch_size']\\n start_index = 0\\n while start_index + batch_size < 500:\\n end_index = start_index + batch_size\\n yield self.input[start_index:end_index], self.y[start_index:end_index]\\n start_index = end_index\",\n \"def next_batch(self):\\n # Whether an epoch is done.\\n done = False\\n samples = []\\n for _ in range(self.batch_size):\\n # Indeed, `>` will not occur.\\n if self.ptr >= self.dataset_size:\\n done = True\\n break\\n else:\\n self.ptr += 1\\n sample = self.enqueuer.queue.get()\\n samples.append(sample)\\n # print 'queue size: {}'.format(self.enqueuer.queue.qsize())\\n # Indeed, `>` will not occur.\\n if self.ptr >= self.dataset_size:\\n done = True\\n return samples, done\",\n \"def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\\n return self._values.get('max_batching_window')\",\n \"def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\\n return self._values.get('max_batching_window')\",\n \"def max_batching_window(self) -> typing.Optional[aws_cdk.core.Duration]:\\n return self._values.get('max_batching_window')\",\n \"def train_dynamic(batch_size=10):\\n \\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6829763","0.63745177","0.6135504","0.6097213","0.60270363","0.59971696","0.5886409","0.5588769","0.5547144","0.55365115","0.5511294","0.55018145","0.5477585","0.5467263","0.54394144","0.5351245","0.53225625","0.53225625","0.53225625","0.53225625","0.52915865","0.52565306","0.5244268","0.5244268","0.5244268","0.5244268","0.52200854","0.5215194","0.52132463","0.51738775","0.5172817","0.51261413","0.5093524","0.50768274","0.5042808","0.50413835","0.50240433","0.50051385","0.49522966","0.4952097","0.4942096","0.49359027","0.49339613","0.4918338","0.4907964","0.49072936","0.48932785","0.48847315","0.48774704","0.48510036","0.48433387","0.4833988","0.48336107","0.48329565","0.4825394","0.48071757","0.47850147","0.47840536","0.4751383","0.47476903","0.47459322","0.47064692","0.4699173","0.46897465","0.46751386","0.46708438","0.46666625","0.46599618","0.46551463","0.4653388","0.4647359","0.46340147","0.46253866","0.4624071","0.46209487","0.4618165","0.46176532","0.46144202","0.46121776","0.46116048","0.46086174","0.45974356","0.4595725","0.45943585","0.45940033","0.45853534","0.45806214","0.45797914","0.45789543","0.45763037","0.45753714","0.4557641","0.45504916","0.45494097","0.45491627","0.45418888","0.45379227","0.45379227","0.45379227","0.4537518"],"string":"[\n \"0.6829763\",\n \"0.63745177\",\n \"0.6135504\",\n \"0.6097213\",\n \"0.60270363\",\n \"0.59971696\",\n \"0.5886409\",\n \"0.5588769\",\n \"0.5547144\",\n \"0.55365115\",\n \"0.5511294\",\n \"0.55018145\",\n \"0.5477585\",\n \"0.5467263\",\n \"0.54394144\",\n \"0.5351245\",\n \"0.53225625\",\n \"0.53225625\",\n \"0.53225625\",\n \"0.53225625\",\n \"0.52915865\",\n \"0.52565306\",\n \"0.5244268\",\n \"0.5244268\",\n \"0.5244268\",\n \"0.5244268\",\n \"0.52200854\",\n \"0.5215194\",\n \"0.52132463\",\n \"0.51738775\",\n \"0.5172817\",\n \"0.51261413\",\n \"0.5093524\",\n \"0.50768274\",\n \"0.5042808\",\n \"0.50413835\",\n \"0.50240433\",\n \"0.50051385\",\n \"0.49522966\",\n \"0.4952097\",\n \"0.4942096\",\n \"0.49359027\",\n \"0.49339613\",\n \"0.4918338\",\n \"0.4907964\",\n \"0.49072936\",\n \"0.48932785\",\n \"0.48847315\",\n \"0.48774704\",\n \"0.48510036\",\n \"0.48433387\",\n \"0.4833988\",\n \"0.48336107\",\n \"0.48329565\",\n \"0.4825394\",\n \"0.48071757\",\n \"0.47850147\",\n \"0.47840536\",\n \"0.4751383\",\n \"0.47476903\",\n \"0.47459322\",\n \"0.47064692\",\n \"0.4699173\",\n \"0.46897465\",\n \"0.46751386\",\n \"0.46708438\",\n \"0.46666625\",\n \"0.46599618\",\n \"0.46551463\",\n \"0.4653388\",\n \"0.4647359\",\n \"0.46340147\",\n \"0.46253866\",\n \"0.4624071\",\n \"0.46209487\",\n \"0.4618165\",\n \"0.46176532\",\n \"0.46144202\",\n \"0.46121776\",\n \"0.46116048\",\n \"0.46086174\",\n \"0.45974356\",\n \"0.4595725\",\n \"0.45943585\",\n \"0.45940033\",\n \"0.45853534\",\n \"0.45806214\",\n \"0.45797914\",\n \"0.45789543\",\n \"0.45763037\",\n \"0.45753714\",\n \"0.4557641\",\n \"0.45504916\",\n \"0.45494097\",\n \"0.45491627\",\n \"0.45418888\",\n \"0.45379227\",\n \"0.45379227\",\n \"0.45379227\",\n \"0.4537518\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6470478"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":4198,"cells":{"query":{"kind":"string","value":"The batch size of the environment."},"document":{"kind":"string","value":"def batch_size(self) -> Optional[int]:\n if self.batched:\n raise RuntimeError(\n 'Environment %s marked itself as batched but did not override the '\n 'batch_size property'\n % type(self)\n )\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def batch_size(self):\n return self.size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def batch_size(self):\n return self._batch_size","def get_batch_size():\n return get_global_variable(GraphKeys.BATCH_SIZE)","def batch_size(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"batch_size\")","def batch_size(self) -> ConfigNodePropertyInteger:\n return self._batch_size","def batch_size(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_size\")","def batch_request_size(self):\n return self._batch_request_size","def batch_size(self) -> int:\n ...","def get_global_batch_size(self) -> int:\n return self._global_batch_size","def _get_batch_size(self):\n if self.batch_size == 'auto':\n return self._backend.compute_batch_size()\n else:\n # Fixed batch size strategy\n return self.batch_size","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_size(self) -> typing.Optional[jsii.Number]:\n return self._values.get('batch_size')","def batch_shape(self) -> torch.Size:\n self._check_if_fitted()\n return torch.Size([self.num_mcmc_samples])","def get_evaluation_batch_size():\n return 1","def get_num_batches(self,batch_size):\r\n \r\n return len(self) // batch_size","def get_generator_batch_size(self):\n\n return self.generator_batch_size","def batch_size(self):\n self.validate_shape_and_dtype()\n return self.rgb.shape[0]","def record_batch_size(self):\n return 10000","def batch_size(self):\n if self._batch_size is not None:\n return self._batch_size # custom batch size defined\n if self.task == 'objdet':\n return 8\n annos_per_img = self._annos_per_img[self.dataset]\n if self.task in {'predcls', 'sgcls'}:\n annos_per_img = annos_per_img['pairs']\n elif self.task == 'objcls':\n annos_per_img = annos_per_img['objects']\n elif self.task == 'preddet' and self.filter_multiple_preds:\n annos_per_img = annos_per_img['predicates_filtered']\n elif self.task == 'preddet' and self.filter_duplicate_rels:\n annos_per_img = annos_per_img['duplicates_filtered']\n elif self.task in {'preddet', 'sggen'}:\n annos_per_img = annos_per_img['relations']\n batch_size = ceil(self._annotations_per_batch / annos_per_img)\n return max(batch_size, 2)","def batch_size(self):\n return self._first_rgb.shape[0]","def get_batch_size(self, recip_count: int) -> int:\n Logger.debug(f'In get_batch_size.', TAG)\n yesterdays_count = self._yesterdays_bet_count.get()\n if yesterdays_count < 1:\n yesterdays_count = 1\n size = (DIST_DURATION_PARAM * recip_count // yesterdays_count)\n if size < TX_MIN_BATCH_SIZE:\n size = TX_MIN_BATCH_SIZE\n if size > TX_MAX_BATCH_SIZE:\n size = TX_MAX_BATCH_SIZE\n Logger.debug(f'Returning batch size of {size}', TAG)\n return size","def batch_size(x):\n return tf.to_float(tf.shape(x)[0], name='get_batch_size_in_fl32')","def get_per_slot_batch_size(self) -> int:\n return self._per_slot_batch_size","def number_of_batches(self):\n return int(np.floor(len(self.file_paths_list) / self.batch_size))","def batch_size(features, labels):\n return extract_batch_length(features)","def input_size(self):\n return self.env.input_size","def ExpectedMaxBatchSizes(self, run_params):\n return self.max_batch_sizes","def acq_batch_size(self):\n return self.batch_size * self.batches_per_acquisition","def batch_size_percentage(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"batch_size_percentage\")","def num_batches(self):\n\t\t\n\t\treturn len(self.batch_stats)","def _global_batch_size(self):\n return True","def eval_batch_size(sess=None):\n return eval_global_variable(GraphKeys.BATCH_SIZE, sess)","def max_num_batches(self):\n return self._max_num_batches","def batch_size(self, batch_size: ConfigNodePropertyInteger):\n\n self._batch_size = batch_size","def size():\n return int(os.environ['WORLD_SIZE'])","def size_in_gb(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"size_in_gb\")","def size_in_gb(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"size_in_gb\")","def size_in_gb(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"size_in_gb\")","def get_size(self):\n return self.get_params().shape[0]","def train_size(self) -> int:\n return int(self.data_size * self.__train_fraction)","def batch_size(input_tensor):\n return input_tensor.get_shape().as_list()[0]","def size(self):\n return int(misc.intprod(self.shape))","def __len__(self):\n return math.ceil(self.number_of_images / self.batch_size)","def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_size_percentage\")","def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_size_percentage\")","def total_train_batches(self) -> int:\n return self.trainer.num_training_batches","def get_batch_seq_size(self, sentence):\n batch_size, seq_length, _ = sentence.size()\n self.seq_length = seq_length\n self.batch_size = batch_size\n batch_seq_size = {'sentence_len': self.seq_length,\n 'batch_size': self.batch_size,\n 'is_multi_root': self.is_multi_root,\n 'max_dependency_len': self.max_dependency_len,\n 'use_gpu': self.use_gpu,\n 'length_constraint_on_root': self.length_constraint_on_root}\n\n return batch_seq_size","def size(self, batch):\n x,y,m = batch \n return sum([mm.sum() for mm in m])","def chunksize(self):\n\n return self._chunksize","def dataset_size(self):\n return self.dataset.size","def get_step_size(total_items, batch_size):\n return np.ceil(total_items / batch_size)","def total_predict_batches(self) -> int:\n return sum(self.trainer.num_predict_batches)","def batch_size_percentage(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"batch_size_percentage\")","def batch_size_percentage(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"batch_size_percentage\")","def size(self):\r\n return len(self._train_datas)","def get_train_data_size(self):\n return len(self.pipeline.data['train'])","def chunk_size(self):\r\n return int(self.frame_length * self.sample_rate)","def batch_len(batch):\n flatlist, _ = tree_util.tree_flatten(batch)\n if len(flatlist) < 1:\n return 0\n b = flatlist[0].shape[0]\n assert all(\n arr.shape[0] == b for arr in flatlist if th.is_tensor(arr)\n ), \"Not all arrays have same batchsize!\"\n return b","def size(self):\n\t\treturn self.dims","def chunk_size(self) -> global___Expression:","def dimension_size(self):\n return self._dim","def __len__(self):\n return int(np.ceil(len(self.ids) / self.batch_size))","def chunksize(self):\n\n return self.data.chunksize","def size(self):\n return self.N","def size_gb(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"size_gb\")","def size_gb(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"size_gb\")","def __len__(self):\n return int(np.ceil(self.total_frame_count / self.batch_size))","def get_ent_span_feature_size(self):\n return self.ent_output_size","def getSize(self):\n return self.bf.memory()","def __len__(self):\n return len(self.batches)","def __len__(self):\n return int(np.ceil(self.max_index / float(self.batch_size)))","def size(self):\n return numpy.prod(self.shape)","def __len__(self) -> int:\n num_batches, remainder = divmod(len(self.mapped_triples), self.batch_size)\n if remainder and not self.drop_last:\n num_batches += 1\n return num_batches","def dim(self) -> int:\n return self._n_dim","def window_size(self):\n return self.__train_prop[\"window_size\"]","def size_in_gb(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"size_in_gb\")","def size_in_gb(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"size_in_gb\")","def training_dataset_size(self):\n\n if not self.cs_learning and hasattr(FLAGS, 'orig_size'):\n return FLAGS.orig_size\n\n traindata_size_dir = os.path.join(self.cache_path, 'ds_sizes')\n ensure_dir(traindata_size_dir)\n if not hasattr(FLAGS, 'train_split'):\n setattr(FLAGS, 'train_split', 'train')\n\n size_cache_file = os.path.join(traindata_size_dir, '{}_{}'.format(FLAGS.dataset.lower(), FLAGS.train_split))\n\n if os.path.exists(size_cache_file):\n with open(size_cache_file) as f:\n ds_size = int(f.readline().strip())\n else:\n ds = load_ds() # Loads the dataset.\n [data_X, _, _] = ds.load()\n ds_size = len(data_X)\n with open(size_cache_file, 'w') as f:\n f.write(str(ds_size))\n\n return ds_size","def __len__(self):\n return int(np.floor(len(self.dataset_df) / self.batch_size))","def dimension(self):\n return self.__N","def _update_num_batches(self):\n # maximum possible number of batches is equal to number of whole times\n # batch_size divides in to the number of data points which can be\n # found using integer division\n possible_num_batches = self.inputs.shape[0] // self.batch_size\n if self.max_num_batches == -1:\n self.num_batches = possible_num_batches\n else:\n self.num_batches = min(self.max_num_batches, possible_num_batches)","def __len__(self):\n return int(np.ceil(len(self.image_filenames) / (self.batch_size)))","def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n self._hparams.source_dataset.files)\n return self._dataset_size","def array_size(self):\n return self._array_size","def batch_node_count(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"batch_node_count\")","def size(self):\n return self.size_number","def __len__(self):\n return int(np.floor(len(self.ids) / self.batch_size))","def size(self) -> int:\n\n return self.sizes.sum()","def _get_batch_size(self, tensor, expected_shape, expected_size):\n size = self._size(tensor)\n if self._ndim(tensor) > len(expected_shape) or size > expected_size:\n return size // expected_size\n\n return None","def getGlobalSize(self):\n return self._get_global_size( )","def state_size(self):\n\t\treturn (\n\t\t\ttf.TensorShape([self.args[\"kb_node_max_len\"], self.args[\"mp_state_width\"]]),\n\t\t)","def GlobalSize(self):\n return _hypre.HypreParVector_GlobalSize(self)","def __len__(self):\n return math.ceil(len(self._sampler) / self._batch_size)","def get_size(self):\n tmpsize = 0\n for variable in self.variables:\n tmpsize += variable.get_size()\n for subchunk in self.subchunks:\n tmpsize += subchunk.get_size()\n return tmpsize","def __len__(self):\n return len(self.indexes) // self.batch_size"],"string":"[\n \"def batch_size(self):\\n return self.size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def batch_size(self):\\n return self._batch_size\",\n \"def get_batch_size():\\n return get_global_variable(GraphKeys.BATCH_SIZE)\",\n \"def batch_size(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"batch_size\\\")\",\n \"def batch_size(self) -> ConfigNodePropertyInteger:\\n return self._batch_size\",\n \"def batch_size(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_size\\\")\",\n \"def batch_request_size(self):\\n return self._batch_request_size\",\n \"def batch_size(self) -> int:\\n ...\",\n \"def get_global_batch_size(self) -> int:\\n return self._global_batch_size\",\n \"def _get_batch_size(self):\\n if self.batch_size == 'auto':\\n return self._backend.compute_batch_size()\\n else:\\n # Fixed batch size strategy\\n return self.batch_size\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_size(self) -> typing.Optional[jsii.Number]:\\n return self._values.get('batch_size')\",\n \"def batch_shape(self) -> torch.Size:\\n self._check_if_fitted()\\n return torch.Size([self.num_mcmc_samples])\",\n \"def get_evaluation_batch_size():\\n return 1\",\n \"def get_num_batches(self,batch_size):\\r\\n \\r\\n return len(self) // batch_size\",\n \"def get_generator_batch_size(self):\\n\\n return self.generator_batch_size\",\n \"def batch_size(self):\\n self.validate_shape_and_dtype()\\n return self.rgb.shape[0]\",\n \"def record_batch_size(self):\\n return 10000\",\n \"def batch_size(self):\\n if self._batch_size is not None:\\n return self._batch_size # custom batch size defined\\n if self.task == 'objdet':\\n return 8\\n annos_per_img = self._annos_per_img[self.dataset]\\n if self.task in {'predcls', 'sgcls'}:\\n annos_per_img = annos_per_img['pairs']\\n elif self.task == 'objcls':\\n annos_per_img = annos_per_img['objects']\\n elif self.task == 'preddet' and self.filter_multiple_preds:\\n annos_per_img = annos_per_img['predicates_filtered']\\n elif self.task == 'preddet' and self.filter_duplicate_rels:\\n annos_per_img = annos_per_img['duplicates_filtered']\\n elif self.task in {'preddet', 'sggen'}:\\n annos_per_img = annos_per_img['relations']\\n batch_size = ceil(self._annotations_per_batch / annos_per_img)\\n return max(batch_size, 2)\",\n \"def batch_size(self):\\n return self._first_rgb.shape[0]\",\n \"def get_batch_size(self, recip_count: int) -> int:\\n Logger.debug(f'In get_batch_size.', TAG)\\n yesterdays_count = self._yesterdays_bet_count.get()\\n if yesterdays_count < 1:\\n yesterdays_count = 1\\n size = (DIST_DURATION_PARAM * recip_count // yesterdays_count)\\n if size < TX_MIN_BATCH_SIZE:\\n size = TX_MIN_BATCH_SIZE\\n if size > TX_MAX_BATCH_SIZE:\\n size = TX_MAX_BATCH_SIZE\\n Logger.debug(f'Returning batch size of {size}', TAG)\\n return size\",\n \"def batch_size(x):\\n return tf.to_float(tf.shape(x)[0], name='get_batch_size_in_fl32')\",\n \"def get_per_slot_batch_size(self) -> int:\\n return self._per_slot_batch_size\",\n \"def number_of_batches(self):\\n return int(np.floor(len(self.file_paths_list) / self.batch_size))\",\n \"def batch_size(features, labels):\\n return extract_batch_length(features)\",\n \"def input_size(self):\\n return self.env.input_size\",\n \"def ExpectedMaxBatchSizes(self, run_params):\\n return self.max_batch_sizes\",\n \"def acq_batch_size(self):\\n return self.batch_size * self.batches_per_acquisition\",\n \"def batch_size_percentage(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"batch_size_percentage\\\")\",\n \"def num_batches(self):\\n\\t\\t\\n\\t\\treturn len(self.batch_stats)\",\n \"def _global_batch_size(self):\\n return True\",\n \"def eval_batch_size(sess=None):\\n return eval_global_variable(GraphKeys.BATCH_SIZE, sess)\",\n \"def max_num_batches(self):\\n return self._max_num_batches\",\n \"def batch_size(self, batch_size: ConfigNodePropertyInteger):\\n\\n self._batch_size = batch_size\",\n \"def size():\\n return int(os.environ['WORLD_SIZE'])\",\n \"def size_in_gb(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"size_in_gb\\\")\",\n \"def size_in_gb(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"size_in_gb\\\")\",\n \"def size_in_gb(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"size_in_gb\\\")\",\n \"def get_size(self):\\n return self.get_params().shape[0]\",\n \"def train_size(self) -> int:\\n return int(self.data_size * self.__train_fraction)\",\n \"def batch_size(input_tensor):\\n return input_tensor.get_shape().as_list()[0]\",\n \"def size(self):\\n return int(misc.intprod(self.shape))\",\n \"def __len__(self):\\n return math.ceil(self.number_of_images / self.batch_size)\",\n \"def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_size_percentage\\\")\",\n \"def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_size_percentage\\\")\",\n \"def total_train_batches(self) -> int:\\n return self.trainer.num_training_batches\",\n \"def get_batch_seq_size(self, sentence):\\n batch_size, seq_length, _ = sentence.size()\\n self.seq_length = seq_length\\n self.batch_size = batch_size\\n batch_seq_size = {'sentence_len': self.seq_length,\\n 'batch_size': self.batch_size,\\n 'is_multi_root': self.is_multi_root,\\n 'max_dependency_len': self.max_dependency_len,\\n 'use_gpu': self.use_gpu,\\n 'length_constraint_on_root': self.length_constraint_on_root}\\n\\n return batch_seq_size\",\n \"def size(self, batch):\\n x,y,m = batch \\n return sum([mm.sum() for mm in m])\",\n \"def chunksize(self):\\n\\n return self._chunksize\",\n \"def dataset_size(self):\\n return self.dataset.size\",\n \"def get_step_size(total_items, batch_size):\\n return np.ceil(total_items / batch_size)\",\n \"def total_predict_batches(self) -> int:\\n return sum(self.trainer.num_predict_batches)\",\n \"def batch_size_percentage(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"batch_size_percentage\\\")\",\n \"def batch_size_percentage(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"batch_size_percentage\\\")\",\n \"def size(self):\\r\\n return len(self._train_datas)\",\n \"def get_train_data_size(self):\\n return len(self.pipeline.data['train'])\",\n \"def chunk_size(self):\\r\\n return int(self.frame_length * self.sample_rate)\",\n \"def batch_len(batch):\\n flatlist, _ = tree_util.tree_flatten(batch)\\n if len(flatlist) < 1:\\n return 0\\n b = flatlist[0].shape[0]\\n assert all(\\n arr.shape[0] == b for arr in flatlist if th.is_tensor(arr)\\n ), \\\"Not all arrays have same batchsize!\\\"\\n return b\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def chunk_size(self) -> global___Expression:\",\n \"def dimension_size(self):\\n return self._dim\",\n \"def __len__(self):\\n return int(np.ceil(len(self.ids) / self.batch_size))\",\n \"def chunksize(self):\\n\\n return self.data.chunksize\",\n \"def size(self):\\n return self.N\",\n \"def size_gb(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"size_gb\\\")\",\n \"def size_gb(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"size_gb\\\")\",\n \"def __len__(self):\\n return int(np.ceil(self.total_frame_count / self.batch_size))\",\n \"def get_ent_span_feature_size(self):\\n return self.ent_output_size\",\n \"def getSize(self):\\n return self.bf.memory()\",\n \"def __len__(self):\\n return len(self.batches)\",\n \"def __len__(self):\\n return int(np.ceil(self.max_index / float(self.batch_size)))\",\n \"def size(self):\\n return numpy.prod(self.shape)\",\n \"def __len__(self) -> int:\\n num_batches, remainder = divmod(len(self.mapped_triples), self.batch_size)\\n if remainder and not self.drop_last:\\n num_batches += 1\\n return num_batches\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def window_size(self):\\n return self.__train_prop[\\\"window_size\\\"]\",\n \"def size_in_gb(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"size_in_gb\\\")\",\n \"def size_in_gb(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"size_in_gb\\\")\",\n \"def training_dataset_size(self):\\n\\n if not self.cs_learning and hasattr(FLAGS, 'orig_size'):\\n return FLAGS.orig_size\\n\\n traindata_size_dir = os.path.join(self.cache_path, 'ds_sizes')\\n ensure_dir(traindata_size_dir)\\n if not hasattr(FLAGS, 'train_split'):\\n setattr(FLAGS, 'train_split', 'train')\\n\\n size_cache_file = os.path.join(traindata_size_dir, '{}_{}'.format(FLAGS.dataset.lower(), FLAGS.train_split))\\n\\n if os.path.exists(size_cache_file):\\n with open(size_cache_file) as f:\\n ds_size = int(f.readline().strip())\\n else:\\n ds = load_ds() # Loads the dataset.\\n [data_X, _, _] = ds.load()\\n ds_size = len(data_X)\\n with open(size_cache_file, 'w') as f:\\n f.write(str(ds_size))\\n\\n return ds_size\",\n \"def __len__(self):\\n return int(np.floor(len(self.dataset_df) / self.batch_size))\",\n \"def dimension(self):\\n return self.__N\",\n \"def _update_num_batches(self):\\n # maximum possible number of batches is equal to number of whole times\\n # batch_size divides in to the number of data points which can be\\n # found using integer division\\n possible_num_batches = self.inputs.shape[0] // self.batch_size\\n if self.max_num_batches == -1:\\n self.num_batches = possible_num_batches\\n else:\\n self.num_batches = min(self.max_num_batches, possible_num_batches)\",\n \"def __len__(self):\\n return int(np.ceil(len(self.image_filenames) / (self.batch_size)))\",\n \"def dataset_size(self):\\n if not self._dataset_size:\\n # pylint: disable=attribute-defined-outside-init\\n self._dataset_size = count_file_lines(\\n self._hparams.source_dataset.files)\\n return self._dataset_size\",\n \"def array_size(self):\\n return self._array_size\",\n \"def batch_node_count(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"batch_node_count\\\")\",\n \"def size(self):\\n return self.size_number\",\n \"def __len__(self):\\n return int(np.floor(len(self.ids) / self.batch_size))\",\n \"def size(self) -> int:\\n\\n return self.sizes.sum()\",\n \"def _get_batch_size(self, tensor, expected_shape, expected_size):\\n size = self._size(tensor)\\n if self._ndim(tensor) > len(expected_shape) or size > expected_size:\\n return size // expected_size\\n\\n return None\",\n \"def getGlobalSize(self):\\n return self._get_global_size( )\",\n \"def state_size(self):\\n\\t\\treturn (\\n\\t\\t\\ttf.TensorShape([self.args[\\\"kb_node_max_len\\\"], self.args[\\\"mp_state_width\\\"]]),\\n\\t\\t)\",\n \"def GlobalSize(self):\\n return _hypre.HypreParVector_GlobalSize(self)\",\n \"def __len__(self):\\n return math.ceil(len(self._sampler) / self._batch_size)\",\n \"def get_size(self):\\n tmpsize = 0\\n for variable in self.variables:\\n tmpsize += variable.get_size()\\n for subchunk in self.subchunks:\\n tmpsize += subchunk.get_size()\\n return tmpsize\",\n \"def __len__(self):\\n return len(self.indexes) // self.batch_size\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8748392","0.8526226","0.8526226","0.8526226","0.8526226","0.8332826","0.82787216","0.82280636","0.8090263","0.8073407","0.80665404","0.80136347","0.8010651","0.8002175","0.8002175","0.8002175","0.8002175","0.7821338","0.7717743","0.76162803","0.75835013","0.7577369","0.7482849","0.7477492","0.7456697","0.7443691","0.7434761","0.7410707","0.73818415","0.7373639","0.73424715","0.7314066","0.72372675","0.72368157","0.72245526","0.7199826","0.7173232","0.71658796","0.71607846","0.7119457","0.7093072","0.7093072","0.7093072","0.70770085","0.7076817","0.70643765","0.7060099","0.70474166","0.70411474","0.70411474","0.70146674","0.70055145","0.6984045","0.6981086","0.6947","0.6933843","0.69150734","0.68957824","0.68957824","0.6889237","0.6873225","0.68623924","0.6857491","0.6838837","0.6819186","0.68133605","0.68131876","0.68085223","0.680837","0.6800605","0.6800605","0.679935","0.6785485","0.6785051","0.6780219","0.6775504","0.6770444","0.67590845","0.6751887","0.67443293","0.6725365","0.6725365","0.6704503","0.669706","0.666763","0.66591716","0.665645","0.66532","0.6649343","0.6631341","0.66248304","0.6624744","0.6611511","0.6609779","0.66059047","0.66003615","0.6600167","0.6595153","0.65661263","0.6564034"],"string":"[\n \"0.8748392\",\n \"0.8526226\",\n \"0.8526226\",\n \"0.8526226\",\n \"0.8526226\",\n \"0.8332826\",\n \"0.82787216\",\n \"0.82280636\",\n \"0.8090263\",\n \"0.8073407\",\n \"0.80665404\",\n \"0.80136347\",\n \"0.8010651\",\n \"0.8002175\",\n \"0.8002175\",\n \"0.8002175\",\n \"0.8002175\",\n \"0.7821338\",\n \"0.7717743\",\n \"0.76162803\",\n \"0.75835013\",\n \"0.7577369\",\n \"0.7482849\",\n \"0.7477492\",\n \"0.7456697\",\n \"0.7443691\",\n \"0.7434761\",\n \"0.7410707\",\n \"0.73818415\",\n \"0.7373639\",\n \"0.73424715\",\n \"0.7314066\",\n \"0.72372675\",\n \"0.72368157\",\n \"0.72245526\",\n \"0.7199826\",\n \"0.7173232\",\n \"0.71658796\",\n \"0.71607846\",\n \"0.7119457\",\n \"0.7093072\",\n \"0.7093072\",\n \"0.7093072\",\n \"0.70770085\",\n \"0.7076817\",\n \"0.70643765\",\n \"0.7060099\",\n \"0.70474166\",\n \"0.70411474\",\n \"0.70411474\",\n \"0.70146674\",\n \"0.70055145\",\n \"0.6984045\",\n \"0.6981086\",\n \"0.6947\",\n \"0.6933843\",\n \"0.69150734\",\n \"0.68957824\",\n \"0.68957824\",\n \"0.6889237\",\n \"0.6873225\",\n \"0.68623924\",\n \"0.6857491\",\n \"0.6838837\",\n \"0.6819186\",\n \"0.68133605\",\n \"0.68131876\",\n \"0.68085223\",\n \"0.680837\",\n \"0.6800605\",\n \"0.6800605\",\n \"0.679935\",\n \"0.6785485\",\n \"0.6785051\",\n \"0.6780219\",\n \"0.6775504\",\n \"0.6770444\",\n \"0.67590845\",\n \"0.6751887\",\n \"0.67443293\",\n \"0.6725365\",\n \"0.6725365\",\n \"0.6704503\",\n \"0.669706\",\n \"0.666763\",\n \"0.66591716\",\n \"0.665645\",\n \"0.66532\",\n \"0.6649343\",\n \"0.6631341\",\n \"0.66248304\",\n \"0.6624744\",\n \"0.6611511\",\n \"0.6609779\",\n \"0.66059047\",\n \"0.66003615\",\n \"0.6600167\",\n \"0.6595153\",\n \"0.65661263\",\n \"0.6564034\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7726753"},"document_rank":{"kind":"string","value":"18"}}},{"rowIdx":4199,"cells":{"query":{"kind":"string","value":"Whether the Environmet should reset given the current timestep. By default it only resets when all time_steps are `LAST`."},"document":{"kind":"string","value":"def should_reset(self, current_time_step: ts.TimeStep) -> bool:\n handle_auto_reset = getattr(self, '_handle_auto_reset', False)\n return handle_auto_reset and np.all(current_time_step.is_last())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def reset_values(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"reset_values\")","def reset():\n return True","def reset_values(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"reset_values\")","def reset(self, **kwargs):\n if self._backend_agent:\n self._backend_agent._on_gym_reset_begin(self, **kwargs)\n\n result = self.env.reset(**kwargs)\n if self.steps_done_in_episode > 0 and not self.is_episode_done:\n self.episodes_done += 1\n self.total.episodes_done_inc()\n self.is_episode_done = False\n self.steps_done_in_episode = 0\n\n if self._backend_agent:\n self._backend_agent._on_gym_reset_end(self, result, **kwargs)\n return result","def is_reset(self):\n return self._tag == 'reset'","def is_reset_task_states(self, task_state):\r\n return all(self.is_initial_child_state(child) for child in task_state)","def reset(self) -> ts.TimeStep:\n self._current_time_step = self._reset()\n return self._current_time_step","def should_reset(self):\n # type: () -> bool\n if not self._is_cache_enabled():\n return False\n elapsed = time.time() - self._last_ts\n return elapsed > self._refresh_interval_sec","def last_reset(self):\n native_implementation = getattr(self._feature, \"last_reset\", None)\n\n return native_implementation or super().last_reset","def test_reset(self, scml_system):\n scml_system._t = 12\n scml_system._k = 33\n state_space = scml_system.state_space\n state_positions = scml_system.state_positions\n initial_state = scml_system.reset()\n target = np.array([0, 0, 0, 0, 0, 0, 560]) / scml_system.limits\n assert np.all(initial_state == target), 'Initial states of the system are incorrect'\n assert scml_system._t == 0, 'Time of the system was not set to zero after reset'\n assert scml_system._k == 0, 'Episode step of the system was not set to zero after reset'\n assert scml_system.converter.reset_counter == scml_system.electrical_motor.reset_counter \\\n == scml_system.mechanical_load.reset_counter == scml_system.supply.reset_counter,\\\n 'The reset was not passed to all components of the SCMLSystem'\n assert scml_system._ode_solver.t == 0, 'The ode solver was not reset correctly'\n assert all(scml_system._ode_solver.y == np.zeros_like(\n scml_system.mechanical_load.state_names + scml_system.electrical_motor.CURRENTS, dtype=float\n )), ' The ode solver was not reset correctly'","def IsLocalRerun(self):\n return self.prev_test_run_key is not None","def reset(self):\n self._timestep = np.array([0])","def reset_next_step(self):\n return self._reset_next_step","def get_is_reset(self, timeout = 0):\n response = self.send_command_to_shouter(BP_TOOL.IS_RESET)\n if response == BP_TOOL.ACK:\n return False\n elif response == BP_TOOL.IS_RESET:\n return True\n else:\n return False","def __bool__(self) -> bool:\n if self.initial_value == 1 and self.number_of_steps == 0:\n return True\n return False","def reset(self):\n self.success = False\n self.i = 0\n if self.monitor:\n self.env = gym.wrappers.Monitor(self.env, \"./mountaincar-monitor\", force=True)\n state = self.env.reset()\n state = self.preprocess_state(state)\n state = np.concatenate([state] * self.action_repeat)\n return state","def IsRerun(self):\n return self.prev_test_context is not None","def reset(self):\n self.clock.reset()\n self.microgrid.reset();\n self.steps_beyond_done = None\n self.updateState();\n return self.state","def is_done(self):\n\n # Robosuite envs always rollout to fixed horizon.\n return False","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def is_dry_run(self):\n try:\n v = environment.get(\"Run\")\n return v.lower() == \"dry\"\n except KeyError:\n return False","def is_restarting(self) -> bool:\r\n return False","def reset(self):\n # Initialize the timestep\n self.timestep = 0\n self.state = self.starting_state\n\n if self.from_data:\n self.episode_num += 1\n\n\n return self.starting_state","def reset(self, **kwargs):\r\n if self.was_real_done:\r\n obs = self.env.reset(**kwargs)\r\n else:\r\n # no-op step to advance from terminal/lost life state\r\n obs, _, _, _ = self.env.step(0)\r\n self.lives = self.env.unwrapped.ale.lives()\r\n return obs","def get_reset(self):\n resetcond = \"\"\n # OnConditions in dynamics\n dyn = self.dynamics\n for ev in dyn.event_handlers:\n if(type(ev) is lems.OnCondition):\n for sa in ev.actions:\n if(type(sa) is lems.StateAssignment):\n resetcond+=sa.variable + \" = \" + sa.value + \"\\n\"\n\n rgs = self.dynamics.regimes\n for r in rgs:\n if(r.initial==True): main_regime = r\n elif(r.initial==False): refractory_regime = r\n # OnConditions in main regimes\n roc = main_regime.event_handlers\n for oc in roc:\n if(type(oc) is lems.OnCondition):\n for sa in oc.actions:\n if(type(sa) is lems.StateAssignment):\n resetcond+=sa.variable + \" = \" + sa.value + \"\\n\"\n # OnEntry in refractory regime\n roe = refractory_regime.event_handlers\n for oe in roe:\n if(type(oe) is lems.OnEntry):\n for sa in oe.actions:\n if(type(sa) is lems.StateAssignment):\n resetcond+=sa.variable + \" = \" + sa.value + \"\\n\"\n\n return resetcond","def update_shuttle_state(self):\n if len(self.steps) > self.current_step >= 0:\n step = self.steps[self.current_step]\n if step.is_fulfilled():\n step.end(True)","def is_forced_run(self):\n try:\n v = environment.get(\"Run\")\n return v.lower() == \"force\"\n except KeyError:\n return False","def _reset(self) -> ts.TimeStep:","def reset(self):\n\n return bool(APIConsumer.post(\"/reset\"))","def IsFinal(self):\n return self.state in FINAL_TEST_RUN_STATES","def reset(self):\n self._reset_next_step = False\n self.step_count = 0\n \n self._state = self.state_initializer()\n self._meta_state = self._meta_state_initializer()\n self.task.reset(self._state, self._meta_state)\n self.physics.reset(self._state)\n self.action_space.reset(self._state)\n for rule in self.game_rules:\n rule.reset(self._state, self._meta_state)\n rule.step(self._state, self._meta_state)\n \n return dm_env.restart(self.observation())","def _on_step(self) -> bool:\n\t\t#self.model.get_env().env_method(\"set_model_reference\", self.model.get_parameters())\n\t\tself.env.set_model_reference(self.model.get_parameters())\n\t\tprint(\"current timestep\", self.num_timesteps)\n\t\treturn True","def reset(self):\n return self.env.reset()","def _ShouldStop(self, task_global_step):\n if task_global_step >= self._task_params.train.max_steps:\n tf.logging.info('ShouldStop: step:%6d params.train.max_steps:%6d',\n task_global_step, self._task_params.train.max_steps)\n return True\n\n return False","def _ShouldStop(self, task_global_step):\n if task_global_step >= self._task_params.train.max_steps:\n tf.logging.info('ShouldStop: step:%6d params.train.max_steps:%6d',\n task_global_step, self._task_params.train.max_steps)\n return True\n\n return False","def check_allow_reset(self):\r\n if not self.ready_to_reset:\r\n if self.current_task_number > 0:\r\n last_response_data = self.get_last_response(self.current_task_number - 1)\r\n current_response_data = self.get_current_attributes(self.current_task_number)\r\n\r\n if (current_response_data['min_score_to_attempt'] > last_response_data['score']\r\n or current_response_data['max_score_to_attempt'] < last_response_data['score']):\r\n self.state = self.DONE\r\n self.ready_to_reset = True\r\n\r\n return self.ready_to_reset","def reset_fsm_preempted(self):\n self._fsm_recent_goal_preempted = False","def _allow_reset(self):\r\n return (self.child_state == self.DONE and self.child_attempts < self.max_attempts)","def is_restarting(self) -> bool:\r\n restart_flag = self._restart_flag\r\n # Reset the flag\r\n self._restart_flag = False\r\n\r\n return restart_flag","def is_restarting(self) -> bool:\r\n restart_flag = self._restart_flag\r\n # Reset the flag\r\n self._restart_flag = False\r\n\r\n return restart_flag","def stored_reset(self):\r\n\t\tself.stored_reward = np.zeros((self.num_timesteps - self.first_considered_reward_step,))\r\n\t\tself.stored_optimum = np.zeros_like(self.stored_reward)","def reset(self):\n \n self.env.reset()\n obs, _, done, _ = self.env.step(1)\n if done: \n self.env.reset()\n obs, _, done, _ = self.env.step(2)\n if done: \n self.env.reset()\n \n return obs","def test_reset_temporal_axis(PM_ds_control_3d_full):\r\n smooth = 10\r\n tsmooth_kws = {\"time\": smooth}\r\n first_ori = PM_ds_control_3d_full.time[0].values\r\n first_actual = _reset_temporal_axis(\r\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\"time\"\r\n ).time.values[0]\r\n first_expected = f\"{first_ori}-{first_ori+smooth*1-1}\"\r\n assert first_actual == first_expected","def is_done(self, agent, world) -> bool:\n if self.steps_from_last_reset / self.num_agents > self.episode_length:\n return True\n return False","def check_early_stop(self) -> bool:\n if self.args.early_stopping_steps == -1:\n return False\n return self._steps_since_new_prefix >= self.args.early_stopping_steps","def set_first_machine_time_step(self, first_machine_time_step):","def _hard_reset(self):\n self._reset_specific_envs(np.ones_like(self.episodes_done))\n self._update_other_info()","def hasReset(self, p_int): # real signature unknown; restored from __doc__\n return False","def isSetDefaultTerm(self):\n return _libsbml.Transition_isSetDefaultTerm(self)","def reset(self):\n if self.reset_tracker >= self.reset_interval:\n instance = self.sampling_function()\n self.env.use_next_instance(instance=instance)\n return self.env.reset()","def should_trigger_for_step(self, step):\n if self._last_triggered_step == step:\n return False\n\n if self._every_steps is not None:\n if step >= self._last_triggered_step + self._every_steps:\n return True\n return False","def must_run(self):\r\n self.current_time = datetime.now()\r\n return all([self._minute(), self._hour(), self._day_of_month(), self._month(), self._day_of_week()])","def reinitialize_conditions(self):\n if self._plumb is not None and self.current_step is not None:\n time = self._plumb.time\n pressures = self._plumb.current_pressures()\n state = {'time': time, 'pressures': pressures}\n\n for condition, _ in self.current_step.conditions:\n condition.reinitialize(state)","def _should_reinitialize_check_run(self, payload):\n state = payload.get('state')\n context = payload.get('context')\n logger.debug(f'status context: {context}, state: {state}')\n return context == CI_STATUS_CONTEXT and state != 'success'","def reset_env(self):\n return self.env.reset()","def reset_continued(self): \n self._recent_goal_continued = False\n self._update_action = False\n self._update_action_without_pause = False","def is_steady_state(self):\n if isinstance(self.problem, TimeMixin):\n return self.problem.steady_state\n return True","def requires_restart(self):\n options = InvenTreeSetting.SETTINGS.get(self.key, None)\n\n if options:\n return options.get('requires_restart', False)\n else:\n return False","def reset(self):\n while not self._check_episode_start_condition():\n self._simulate()\n self.state, _ = self._extract_state()\n return self.state","def is_sim_end(self):\n\n return self.cur_round == self.num_rounds + 1","def auto_renew(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"auto_renew\")","def auto_renew(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"auto_renew\")","def reset_world(self, world):\n self.steps_from_last_reset = 0","def trigger(self):\n if self.timer is None or time.time() - self.last_try > self.min_sec * 2:\n self.timer = time.time()\n self.last_try = time.time()\n return False\n elif time.time() - self.timer > self.min_sec:\n self.reset()\n return True\n else:\n self.last_try = time.time()\n return False","def test_issue_reset_time(self):\n pass","def reset(self, **kwargs):\n return self.env.reset(**kwargs)","def finished(self, step: t.Optional[int] = None) -> bool:\n if step is None:\n return self.status() == self.expectedstatus()\n return self.status() & (1 << step)","def test_correctly_sets_halt_on_next(self, get_pipe_manager):\n\n # Establish manager and perform initial control assertions.\n pm = get_pipe_manager(name=\"TestPM\")\n pm.stop_after = \"step2\"\n assert not pm.halt_on_next\n\n # Make non-halt-status-altering checkpointed timestamp call and\n # verify that we're still running and that we're not scheduled to halt.\n pm.timestamp(checkpoint=\"step1\")\n assert not pm.halt_on_next\n\n # Make halt-status-altering checkpointed timestamp call and verify\n # that we're still running and that we've now been scheduled to halt.\n pm.timestamp(checkpoint=\"step2\")\n assert pm.halt_on_next","def reset(self):\n\n for value in self.__dict__.itervalues():\n if isinstance(value, EnvParm):\n value._value = 'use_env'\n getattr(value, 'value')","def reset(self):\n if self._draw_new_turn_on_reset:\n turn_params = self._draw_random_turn_params()\n config = AisleTurnEnvParams(turn_params=turn_params, env_params=self._env_params)\n self._env = AisleTurnEnv(config)\n\n return self._env.reset()","def __check_mode_change(self):\n if self.mode[\"auto_mode\"] != self.mode[\"last_mode\"]:\n self.mode[\"last_mode\"] = self.mode[\"auto_mode\"]\n return True\n return False","def test_env_reset_and_step(self):\n create_env = CreateEnv()\n env = create_env.env\n\n # Assert that the total number of agents matches the sum of the 'n_agents'\n # configuration and the number of planners (1 in this case)\n num_planners = 1\n self.assertEqual(\n len(env.all_agents), create_env.env_config[\"n_agents\"] + num_planners\n )\n\n # Assert that the number of agents created in the world\n # matches the configuration specification\n self.assertEqual(len(env.world.agents), create_env.env_config[\"n_agents\"])\n\n # Assert that the planner's index in the world is 'p'\n self.assertEqual(env.world.planner.idx, \"p\")\n\n obs = env.reset()\n\n # Test whether the observation dictionary keys are created as expected\n self.assertEqual(\n sorted(list(obs.keys())),\n [str(i) for i in range(create_env.env_config[\"n_agents\"])] + [\"p\"],\n )\n\n obs, reward, done, info = env.step({})\n\n # Check that the observation, reward and info keys match\n self.assertEqual(obs.keys(), reward.keys())\n self.assertEqual(obs.keys(), info.keys())\n\n # Assert that __all__ is in done\n assert \"__all__\" in done","def reset(self, **kwargs):\n self.env.reset(**kwargs)\n if self.override_num_noops is not None:\n noops = self.override_num_noops\n else:\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101\n assert noops > 0\n obs = None\n for _ in range(noops):\n obs, _, done, _ = self.env.step(self.noop_action)\n if done:\n obs = self.env.reset(**kwargs)\n return obs","def test_reset_tenant_token_later(self):\n new_token, orig_token = self._check_reset_token(invalidate=False)\n self.assertEqual(new_token.previous, orig_token.valid)","def reset(dut):\n\n dut.reset_n <= 1\n yield ClockCycles(dut.clock, 10)\n dut.reset_n <= 0\n yield ClockCycles(dut.clock, 10)\n dut.reset_n <= 1","def _restart_environment_episode(self, force_environment_reset=False) -> None:\n raise NotImplementedError(\"\")","def reset(self, **kwargs):\n self.env.reset(**kwargs)\n if self.override_num_noops is not None:\n noops = self.override_num_noops\n else:\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) # pylint: disable=E1101\n assert noops > 0\n obs = None\n for _ in range(noops):\n obs, _, done, _ = self.env.step(self.noop_action)\n if done:\n obs = self.env.reset(**kwargs)\n return obs","def auto_renew(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"auto_renew\")","def test_reset_computer(self):\n computer1 = computer.Computer(1)\n computer1.reset_computer()\n res = computer1.greediness == 7 and computer1.rolls == 0\n self.assertTrue(res)","def recurrent(self):\n return False","def auto_renew(self) -> Optional[bool]:\n return pulumi.get(self, \"auto_renew\")","def auto_renew(self) -> Optional[bool]:\n return pulumi.get(self, \"auto_renew\")","def reset(self, **kwargs):\n self.env.reset(**kwargs)\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1)\n obs = None\n for _ in range(noops):\n obs, _, done, _ = self.env.step(self.noop_action)\n if done:\n obs = self.env.reset(**kwargs)\n return obs","def epidemic_finish(states, iteration):\n return np.sum(states) == 0 and iteration > 10","def _compute_is_terminal(self):\n # by default the episode will terminate when all samples are labelled\n done = LalEnv._compute_is_terminal(self)\n # it also terminates when self.n_horizon datapoints were labelled\n if np.size(self.indeces_known) == self.n_horizon:\n done = True\n return done","def reset_camera(i, cam):\n\ttry:\n\t\tresult = True\n\n\t\tprint('*** RESETTING CAMERA SETTINGS ***')\n\n\t\tif cam.GetUniqueID() == serial_1:\t\t\n\t\t\tresult &= auto_exposure_mode(i, cam, 'Continuous')\n\t\t\tresult &= auto_gain_mode(i, cam, 'Continuous')\n\n\t\t\tcam.V3_3Enable.SetValue(False)\n\t\t\tcam.LineSelector.SetValue(PySpin.LineSelector_Line0)\n\t\t\tcam.TriggerMode.SetValue(PySpin.TriggerMode_Off)\n\n\t\tif cam.GetUniqueID() == serial_2:\t\t\n\t\t\tresult &= auto_exposure_mode(i, cam, 'Continuous')\n\t\t\tresult &= auto_gain_mode(i, cam, 'Continuous')\n\t\t\tcam.TriggerMode.SetValue(PySpin.TriggerMode_Off)\n\t\tprint('\\n')\n\n\texcept PySpin.SpinnakerException as ex:\n\t\tprint('Error: %s' % ex)\n\n\treturn result","def _verify_agent_reset(self):\n if self._ia_client is None:\n return\n\n state = self._ia_client.get_agent_state()\n if state != ResourceAgentState.UNINITIALIZED:\n cmd = AgentCommand(command=ResourceAgentEvent.RESET)\n retval = self._ia_client.execute_agent(cmd)","def until_reset(self) -> int:\n return int((self.resets_at - datetime.now()).total_seconds())","def if_end(self, **kwargs):\n\n index = self.get('_index')\n\n if index and index >= len(self.steps)-1:\n return True # all steps have been used\n\n return False","def reset(self, time):\n for key in self.data['step']:\n self.data['step'][key] = None\n\n self.time = time","def __init__(self, handle_auto_reset: bool = False):\n self._handle_auto_reset = handle_auto_reset\n self._current_time_step = None\n common.assert_members_are_not_overridden(\n base_cls=PyEnvironment, instance=self, denylist=('reset', 'step')\n )","def is_last(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"is_last\")","def _is_valid_reset(self, reset):\n if reset.ResetType() in ('Single', 'Compound', 'Weighted'):\n reset_date = reset.Day()\n if reset_date >= self.start_date and reset_date <= self.end_date:\n return True\n\n return False","def _set(env_var: str) -> bool:\n return os.getenv(env_var) not in [None, \"0\"]","def reset_target(scope) -> None:\n if globals.cw_platform == \"CW303\" or globals.cw_platform == \"CWLITEXMEGA\":\n scope.io.pdic = 'low'\n time.sleep(0.1)\n scope.io.pdic = 'high_z' #XMEGA doesn't like pdic driven high\n time.sleep(0.1) #xmega needs more startup time\n else: \n scope.io.nrst = 'low'\n time.sleep(0.05)\n scope.io.nrst = 'high_z'\n time.sleep(0.05)"],"string":"[\n \"def reset_values(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"reset_values\\\")\",\n \"def reset():\\n return True\",\n \"def reset_values(self) -> pulumi.Output[Optional[bool]]:\\n return pulumi.get(self, \\\"reset_values\\\")\",\n \"def reset(self, **kwargs):\\n if self._backend_agent:\\n self._backend_agent._on_gym_reset_begin(self, **kwargs)\\n\\n result = self.env.reset(**kwargs)\\n if self.steps_done_in_episode > 0 and not self.is_episode_done:\\n self.episodes_done += 1\\n self.total.episodes_done_inc()\\n self.is_episode_done = False\\n self.steps_done_in_episode = 0\\n\\n if self._backend_agent:\\n self._backend_agent._on_gym_reset_end(self, result, **kwargs)\\n return result\",\n \"def is_reset(self):\\n return self._tag == 'reset'\",\n \"def is_reset_task_states(self, task_state):\\r\\n return all(self.is_initial_child_state(child) for child in task_state)\",\n \"def reset(self) -> ts.TimeStep:\\n self._current_time_step = self._reset()\\n return self._current_time_step\",\n \"def should_reset(self):\\n # type: () -> bool\\n if not self._is_cache_enabled():\\n return False\\n elapsed = time.time() - self._last_ts\\n return elapsed > self._refresh_interval_sec\",\n \"def last_reset(self):\\n native_implementation = getattr(self._feature, \\\"last_reset\\\", None)\\n\\n return native_implementation or super().last_reset\",\n \"def test_reset(self, scml_system):\\n scml_system._t = 12\\n scml_system._k = 33\\n state_space = scml_system.state_space\\n state_positions = scml_system.state_positions\\n initial_state = scml_system.reset()\\n target = np.array([0, 0, 0, 0, 0, 0, 560]) / scml_system.limits\\n assert np.all(initial_state == target), 'Initial states of the system are incorrect'\\n assert scml_system._t == 0, 'Time of the system was not set to zero after reset'\\n assert scml_system._k == 0, 'Episode step of the system was not set to zero after reset'\\n assert scml_system.converter.reset_counter == scml_system.electrical_motor.reset_counter \\\\\\n == scml_system.mechanical_load.reset_counter == scml_system.supply.reset_counter,\\\\\\n 'The reset was not passed to all components of the SCMLSystem'\\n assert scml_system._ode_solver.t == 0, 'The ode solver was not reset correctly'\\n assert all(scml_system._ode_solver.y == np.zeros_like(\\n scml_system.mechanical_load.state_names + scml_system.electrical_motor.CURRENTS, dtype=float\\n )), ' The ode solver was not reset correctly'\",\n \"def IsLocalRerun(self):\\n return self.prev_test_run_key is not None\",\n \"def reset(self):\\n self._timestep = np.array([0])\",\n \"def reset_next_step(self):\\n return self._reset_next_step\",\n \"def get_is_reset(self, timeout = 0):\\n response = self.send_command_to_shouter(BP_TOOL.IS_RESET)\\n if response == BP_TOOL.ACK:\\n return False\\n elif response == BP_TOOL.IS_RESET:\\n return True\\n else:\\n return False\",\n \"def __bool__(self) -> bool:\\n if self.initial_value == 1 and self.number_of_steps == 0:\\n return True\\n return False\",\n \"def reset(self):\\n self.success = False\\n self.i = 0\\n if self.monitor:\\n self.env = gym.wrappers.Monitor(self.env, \\\"./mountaincar-monitor\\\", force=True)\\n state = self.env.reset()\\n state = self.preprocess_state(state)\\n state = np.concatenate([state] * self.action_repeat)\\n return state\",\n \"def IsRerun(self):\\n return self.prev_test_context is not None\",\n \"def reset(self):\\n self.clock.reset()\\n self.microgrid.reset();\\n self.steps_beyond_done = None\\n self.updateState();\\n return self.state\",\n \"def is_done(self):\\n\\n # Robosuite envs always rollout to fixed horizon.\\n return False\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def is_dry_run(self):\\n try:\\n v = environment.get(\\\"Run\\\")\\n return v.lower() == \\\"dry\\\"\\n except KeyError:\\n return False\",\n \"def is_restarting(self) -> bool:\\r\\n return False\",\n \"def reset(self):\\n # Initialize the timestep\\n self.timestep = 0\\n self.state = self.starting_state\\n\\n if self.from_data:\\n self.episode_num += 1\\n\\n\\n return self.starting_state\",\n \"def reset(self, **kwargs):\\r\\n if self.was_real_done:\\r\\n obs = self.env.reset(**kwargs)\\r\\n else:\\r\\n # no-op step to advance from terminal/lost life state\\r\\n obs, _, _, _ = self.env.step(0)\\r\\n self.lives = self.env.unwrapped.ale.lives()\\r\\n return obs\",\n \"def get_reset(self):\\n resetcond = \\\"\\\"\\n # OnConditions in dynamics\\n dyn = self.dynamics\\n for ev in dyn.event_handlers:\\n if(type(ev) is lems.OnCondition):\\n for sa in ev.actions:\\n if(type(sa) is lems.StateAssignment):\\n resetcond+=sa.variable + \\\" = \\\" + sa.value + \\\"\\\\n\\\"\\n\\n rgs = self.dynamics.regimes\\n for r in rgs:\\n if(r.initial==True): main_regime = r\\n elif(r.initial==False): refractory_regime = r\\n # OnConditions in main regimes\\n roc = main_regime.event_handlers\\n for oc in roc:\\n if(type(oc) is lems.OnCondition):\\n for sa in oc.actions:\\n if(type(sa) is lems.StateAssignment):\\n resetcond+=sa.variable + \\\" = \\\" + sa.value + \\\"\\\\n\\\"\\n # OnEntry in refractory regime\\n roe = refractory_regime.event_handlers\\n for oe in roe:\\n if(type(oe) is lems.OnEntry):\\n for sa in oe.actions:\\n if(type(sa) is lems.StateAssignment):\\n resetcond+=sa.variable + \\\" = \\\" + sa.value + \\\"\\\\n\\\"\\n\\n return resetcond\",\n \"def update_shuttle_state(self):\\n if len(self.steps) > self.current_step >= 0:\\n step = self.steps[self.current_step]\\n if step.is_fulfilled():\\n step.end(True)\",\n \"def is_forced_run(self):\\n try:\\n v = environment.get(\\\"Run\\\")\\n return v.lower() == \\\"force\\\"\\n except KeyError:\\n return False\",\n \"def _reset(self) -> ts.TimeStep:\",\n \"def reset(self):\\n\\n return bool(APIConsumer.post(\\\"/reset\\\"))\",\n \"def IsFinal(self):\\n return self.state in FINAL_TEST_RUN_STATES\",\n \"def reset(self):\\n self._reset_next_step = False\\n self.step_count = 0\\n \\n self._state = self.state_initializer()\\n self._meta_state = self._meta_state_initializer()\\n self.task.reset(self._state, self._meta_state)\\n self.physics.reset(self._state)\\n self.action_space.reset(self._state)\\n for rule in self.game_rules:\\n rule.reset(self._state, self._meta_state)\\n rule.step(self._state, self._meta_state)\\n \\n return dm_env.restart(self.observation())\",\n \"def _on_step(self) -> bool:\\n\\t\\t#self.model.get_env().env_method(\\\"set_model_reference\\\", self.model.get_parameters())\\n\\t\\tself.env.set_model_reference(self.model.get_parameters())\\n\\t\\tprint(\\\"current timestep\\\", self.num_timesteps)\\n\\t\\treturn True\",\n \"def reset(self):\\n return self.env.reset()\",\n \"def _ShouldStop(self, task_global_step):\\n if task_global_step >= self._task_params.train.max_steps:\\n tf.logging.info('ShouldStop: step:%6d params.train.max_steps:%6d',\\n task_global_step, self._task_params.train.max_steps)\\n return True\\n\\n return False\",\n \"def _ShouldStop(self, task_global_step):\\n if task_global_step >= self._task_params.train.max_steps:\\n tf.logging.info('ShouldStop: step:%6d params.train.max_steps:%6d',\\n task_global_step, self._task_params.train.max_steps)\\n return True\\n\\n return False\",\n \"def check_allow_reset(self):\\r\\n if not self.ready_to_reset:\\r\\n if self.current_task_number > 0:\\r\\n last_response_data = self.get_last_response(self.current_task_number - 1)\\r\\n current_response_data = self.get_current_attributes(self.current_task_number)\\r\\n\\r\\n if (current_response_data['min_score_to_attempt'] > last_response_data['score']\\r\\n or current_response_data['max_score_to_attempt'] < last_response_data['score']):\\r\\n self.state = self.DONE\\r\\n self.ready_to_reset = True\\r\\n\\r\\n return self.ready_to_reset\",\n \"def reset_fsm_preempted(self):\\n self._fsm_recent_goal_preempted = False\",\n \"def _allow_reset(self):\\r\\n return (self.child_state == self.DONE and self.child_attempts < self.max_attempts)\",\n \"def is_restarting(self) -> bool:\\r\\n restart_flag = self._restart_flag\\r\\n # Reset the flag\\r\\n self._restart_flag = False\\r\\n\\r\\n return restart_flag\",\n \"def is_restarting(self) -> bool:\\r\\n restart_flag = self._restart_flag\\r\\n # Reset the flag\\r\\n self._restart_flag = False\\r\\n\\r\\n return restart_flag\",\n \"def stored_reset(self):\\r\\n\\t\\tself.stored_reward = np.zeros((self.num_timesteps - self.first_considered_reward_step,))\\r\\n\\t\\tself.stored_optimum = np.zeros_like(self.stored_reward)\",\n \"def reset(self):\\n \\n self.env.reset()\\n obs, _, done, _ = self.env.step(1)\\n if done: \\n self.env.reset()\\n obs, _, done, _ = self.env.step(2)\\n if done: \\n self.env.reset()\\n \\n return obs\",\n \"def test_reset_temporal_axis(PM_ds_control_3d_full):\\r\\n smooth = 10\\r\\n tsmooth_kws = {\\\"time\\\": smooth}\\r\\n first_ori = PM_ds_control_3d_full.time[0].values\\r\\n first_actual = _reset_temporal_axis(\\r\\n PM_ds_control_3d_full, tsmooth_kws=tsmooth_kws, dim=\\\"time\\\"\\r\\n ).time.values[0]\\r\\n first_expected = f\\\"{first_ori}-{first_ori+smooth*1-1}\\\"\\r\\n assert first_actual == first_expected\",\n \"def is_done(self, agent, world) -> bool:\\n if self.steps_from_last_reset / self.num_agents > self.episode_length:\\n return True\\n return False\",\n \"def check_early_stop(self) -> bool:\\n if self.args.early_stopping_steps == -1:\\n return False\\n return self._steps_since_new_prefix >= self.args.early_stopping_steps\",\n \"def set_first_machine_time_step(self, first_machine_time_step):\",\n \"def _hard_reset(self):\\n self._reset_specific_envs(np.ones_like(self.episodes_done))\\n self._update_other_info()\",\n \"def hasReset(self, p_int): # real signature unknown; restored from __doc__\\n return False\",\n \"def isSetDefaultTerm(self):\\n return _libsbml.Transition_isSetDefaultTerm(self)\",\n \"def reset(self):\\n if self.reset_tracker >= self.reset_interval:\\n instance = self.sampling_function()\\n self.env.use_next_instance(instance=instance)\\n return self.env.reset()\",\n \"def should_trigger_for_step(self, step):\\n if self._last_triggered_step == step:\\n return False\\n\\n if self._every_steps is not None:\\n if step >= self._last_triggered_step + self._every_steps:\\n return True\\n return False\",\n \"def must_run(self):\\r\\n self.current_time = datetime.now()\\r\\n return all([self._minute(), self._hour(), self._day_of_month(), self._month(), self._day_of_week()])\",\n \"def reinitialize_conditions(self):\\n if self._plumb is not None and self.current_step is not None:\\n time = self._plumb.time\\n pressures = self._plumb.current_pressures()\\n state = {'time': time, 'pressures': pressures}\\n\\n for condition, _ in self.current_step.conditions:\\n condition.reinitialize(state)\",\n \"def _should_reinitialize_check_run(self, payload):\\n state = payload.get('state')\\n context = payload.get('context')\\n logger.debug(f'status context: {context}, state: {state}')\\n return context == CI_STATUS_CONTEXT and state != 'success'\",\n \"def reset_env(self):\\n return self.env.reset()\",\n \"def reset_continued(self): \\n self._recent_goal_continued = False\\n self._update_action = False\\n self._update_action_without_pause = False\",\n \"def is_steady_state(self):\\n if isinstance(self.problem, TimeMixin):\\n return self.problem.steady_state\\n return True\",\n \"def requires_restart(self):\\n options = InvenTreeSetting.SETTINGS.get(self.key, None)\\n\\n if options:\\n return options.get('requires_restart', False)\\n else:\\n return False\",\n \"def reset(self):\\n while not self._check_episode_start_condition():\\n self._simulate()\\n self.state, _ = self._extract_state()\\n return self.state\",\n \"def is_sim_end(self):\\n\\n return self.cur_round == self.num_rounds + 1\",\n \"def auto_renew(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"auto_renew\\\")\",\n \"def auto_renew(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"auto_renew\\\")\",\n \"def reset_world(self, world):\\n self.steps_from_last_reset = 0\",\n \"def trigger(self):\\n if self.timer is None or time.time() - self.last_try > self.min_sec * 2:\\n self.timer = time.time()\\n self.last_try = time.time()\\n return False\\n elif time.time() - self.timer > self.min_sec:\\n self.reset()\\n return True\\n else:\\n self.last_try = time.time()\\n return False\",\n \"def test_issue_reset_time(self):\\n pass\",\n \"def reset(self, **kwargs):\\n return self.env.reset(**kwargs)\",\n \"def finished(self, step: t.Optional[int] = None) -> bool:\\n if step is None:\\n return self.status() == self.expectedstatus()\\n return self.status() & (1 << step)\",\n \"def test_correctly_sets_halt_on_next(self, get_pipe_manager):\\n\\n # Establish manager and perform initial control assertions.\\n pm = get_pipe_manager(name=\\\"TestPM\\\")\\n pm.stop_after = \\\"step2\\\"\\n assert not pm.halt_on_next\\n\\n # Make non-halt-status-altering checkpointed timestamp call and\\n # verify that we're still running and that we're not scheduled to halt.\\n pm.timestamp(checkpoint=\\\"step1\\\")\\n assert not pm.halt_on_next\\n\\n # Make halt-status-altering checkpointed timestamp call and verify\\n # that we're still running and that we've now been scheduled to halt.\\n pm.timestamp(checkpoint=\\\"step2\\\")\\n assert pm.halt_on_next\",\n \"def reset(self):\\n\\n for value in self.__dict__.itervalues():\\n if isinstance(value, EnvParm):\\n value._value = 'use_env'\\n getattr(value, 'value')\",\n \"def reset(self):\\n if self._draw_new_turn_on_reset:\\n turn_params = self._draw_random_turn_params()\\n config = AisleTurnEnvParams(turn_params=turn_params, env_params=self._env_params)\\n self._env = AisleTurnEnv(config)\\n\\n return self._env.reset()\",\n \"def __check_mode_change(self):\\n if self.mode[\\\"auto_mode\\\"] != self.mode[\\\"last_mode\\\"]:\\n self.mode[\\\"last_mode\\\"] = self.mode[\\\"auto_mode\\\"]\\n return True\\n return False\",\n \"def test_env_reset_and_step(self):\\n create_env = CreateEnv()\\n env = create_env.env\\n\\n # Assert that the total number of agents matches the sum of the 'n_agents'\\n # configuration and the number of planners (1 in this case)\\n num_planners = 1\\n self.assertEqual(\\n len(env.all_agents), create_env.env_config[\\\"n_agents\\\"] + num_planners\\n )\\n\\n # Assert that the number of agents created in the world\\n # matches the configuration specification\\n self.assertEqual(len(env.world.agents), create_env.env_config[\\\"n_agents\\\"])\\n\\n # Assert that the planner's index in the world is 'p'\\n self.assertEqual(env.world.planner.idx, \\\"p\\\")\\n\\n obs = env.reset()\\n\\n # Test whether the observation dictionary keys are created as expected\\n self.assertEqual(\\n sorted(list(obs.keys())),\\n [str(i) for i in range(create_env.env_config[\\\"n_agents\\\"])] + [\\\"p\\\"],\\n )\\n\\n obs, reward, done, info = env.step({})\\n\\n # Check that the observation, reward and info keys match\\n self.assertEqual(obs.keys(), reward.keys())\\n self.assertEqual(obs.keys(), info.keys())\\n\\n # Assert that __all__ is in done\\n assert \\\"__all__\\\" in done\",\n \"def reset(self, **kwargs):\\n self.env.reset(**kwargs)\\n if self.override_num_noops is not None:\\n noops = self.override_num_noops\\n else:\\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101\\n assert noops > 0\\n obs = None\\n for _ in range(noops):\\n obs, _, done, _ = self.env.step(self.noop_action)\\n if done:\\n obs = self.env.reset(**kwargs)\\n return obs\",\n \"def test_reset_tenant_token_later(self):\\n new_token, orig_token = self._check_reset_token(invalidate=False)\\n self.assertEqual(new_token.previous, orig_token.valid)\",\n \"def reset(dut):\\n\\n dut.reset_n <= 1\\n yield ClockCycles(dut.clock, 10)\\n dut.reset_n <= 0\\n yield ClockCycles(dut.clock, 10)\\n dut.reset_n <= 1\",\n \"def _restart_environment_episode(self, force_environment_reset=False) -> None:\\n raise NotImplementedError(\\\"\\\")\",\n \"def reset(self, **kwargs):\\n self.env.reset(**kwargs)\\n if self.override_num_noops is not None:\\n noops = self.override_num_noops\\n else:\\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) # pylint: disable=E1101\\n assert noops > 0\\n obs = None\\n for _ in range(noops):\\n obs, _, done, _ = self.env.step(self.noop_action)\\n if done:\\n obs = self.env.reset(**kwargs)\\n return obs\",\n \"def auto_renew(self) -> pulumi.Output[Optional[bool]]:\\n return pulumi.get(self, \\\"auto_renew\\\")\",\n \"def test_reset_computer(self):\\n computer1 = computer.Computer(1)\\n computer1.reset_computer()\\n res = computer1.greediness == 7 and computer1.rolls == 0\\n self.assertTrue(res)\",\n \"def recurrent(self):\\n return False\",\n \"def auto_renew(self) -> Optional[bool]:\\n return pulumi.get(self, \\\"auto_renew\\\")\",\n \"def auto_renew(self) -> Optional[bool]:\\n return pulumi.get(self, \\\"auto_renew\\\")\",\n \"def reset(self, **kwargs):\\n self.env.reset(**kwargs)\\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1)\\n obs = None\\n for _ in range(noops):\\n obs, _, done, _ = self.env.step(self.noop_action)\\n if done:\\n obs = self.env.reset(**kwargs)\\n return obs\",\n \"def epidemic_finish(states, iteration):\\n return np.sum(states) == 0 and iteration > 10\",\n \"def _compute_is_terminal(self):\\n # by default the episode will terminate when all samples are labelled\\n done = LalEnv._compute_is_terminal(self)\\n # it also terminates when self.n_horizon datapoints were labelled\\n if np.size(self.indeces_known) == self.n_horizon:\\n done = True\\n return done\",\n \"def reset_camera(i, cam):\\n\\ttry:\\n\\t\\tresult = True\\n\\n\\t\\tprint('*** RESETTING CAMERA SETTINGS ***')\\n\\n\\t\\tif cam.GetUniqueID() == serial_1:\\t\\t\\n\\t\\t\\tresult &= auto_exposure_mode(i, cam, 'Continuous')\\n\\t\\t\\tresult &= auto_gain_mode(i, cam, 'Continuous')\\n\\n\\t\\t\\tcam.V3_3Enable.SetValue(False)\\n\\t\\t\\tcam.LineSelector.SetValue(PySpin.LineSelector_Line0)\\n\\t\\t\\tcam.TriggerMode.SetValue(PySpin.TriggerMode_Off)\\n\\n\\t\\tif cam.GetUniqueID() == serial_2:\\t\\t\\n\\t\\t\\tresult &= auto_exposure_mode(i, cam, 'Continuous')\\n\\t\\t\\tresult &= auto_gain_mode(i, cam, 'Continuous')\\n\\t\\t\\tcam.TriggerMode.SetValue(PySpin.TriggerMode_Off)\\n\\t\\tprint('\\\\n')\\n\\n\\texcept PySpin.SpinnakerException as ex:\\n\\t\\tprint('Error: %s' % ex)\\n\\n\\treturn result\",\n \"def _verify_agent_reset(self):\\n if self._ia_client is None:\\n return\\n\\n state = self._ia_client.get_agent_state()\\n if state != ResourceAgentState.UNINITIALIZED:\\n cmd = AgentCommand(command=ResourceAgentEvent.RESET)\\n retval = self._ia_client.execute_agent(cmd)\",\n \"def until_reset(self) -> int:\\n return int((self.resets_at - datetime.now()).total_seconds())\",\n \"def if_end(self, **kwargs):\\n\\n index = self.get('_index')\\n\\n if index and index >= len(self.steps)-1:\\n return True # all steps have been used\\n\\n return False\",\n \"def reset(self, time):\\n for key in self.data['step']:\\n self.data['step'][key] = None\\n\\n self.time = time\",\n \"def __init__(self, handle_auto_reset: bool = False):\\n self._handle_auto_reset = handle_auto_reset\\n self._current_time_step = None\\n common.assert_members_are_not_overridden(\\n base_cls=PyEnvironment, instance=self, denylist=('reset', 'step')\\n )\",\n \"def is_last(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"is_last\\\")\",\n \"def _is_valid_reset(self, reset):\\n if reset.ResetType() in ('Single', 'Compound', 'Weighted'):\\n reset_date = reset.Day()\\n if reset_date >= self.start_date and reset_date <= self.end_date:\\n return True\\n\\n return False\",\n \"def _set(env_var: str) -> bool:\\n return os.getenv(env_var) not in [None, \\\"0\\\"]\",\n \"def reset_target(scope) -> None:\\n if globals.cw_platform == \\\"CW303\\\" or globals.cw_platform == \\\"CWLITEXMEGA\\\":\\n scope.io.pdic = 'low'\\n time.sleep(0.1)\\n scope.io.pdic = 'high_z' #XMEGA doesn't like pdic driven high\\n time.sleep(0.1) #xmega needs more startup time\\n else: \\n scope.io.nrst = 'low'\\n time.sleep(0.05)\\n scope.io.nrst = 'high_z'\\n time.sleep(0.05)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6065845","0.5846722","0.5738438","0.57173324","0.5702698","0.5700601","0.56152225","0.5585178","0.55754685","0.5555264","0.5542493","0.55404925","0.5514392","0.5394026","0.5376499","0.5355567","0.53485197","0.53262925","0.5297183","0.52819175","0.52819175","0.52819175","0.52819175","0.52819175","0.52819175","0.5280383","0.5276791","0.5252488","0.52435327","0.5237724","0.522949","0.5220523","0.5218894","0.52003044","0.51928765","0.5183386","0.5178595","0.5167659","0.5134019","0.5134019","0.5133045","0.5131466","0.5120896","0.51201564","0.51201564","0.511805","0.5103139","0.5096017","0.5093936","0.5081916","0.5075817","0.50745475","0.5063044","0.5061533","0.50506365","0.5037881","0.50338906","0.5029084","0.502597","0.5015943","0.5007547","0.5006716","0.50061625","0.4996792","0.49965736","0.4993423","0.4993423","0.49897972","0.49767748","0.49767298","0.49757093","0.49491033","0.49458483","0.4945029","0.4944715","0.49375892","0.4926302","0.49120924","0.49114105","0.49087328","0.49086422","0.4904369","0.49017486","0.48981065","0.48958537","0.48942623","0.48942623","0.48902318","0.48876482","0.48868796","0.4871556","0.48685995","0.48630232","0.4862149","0.48573598","0.48565975","0.48551467","0.48538715","0.48445508","0.48395744"],"string":"[\n \"0.6065845\",\n \"0.5846722\",\n \"0.5738438\",\n \"0.57173324\",\n \"0.5702698\",\n \"0.5700601\",\n \"0.56152225\",\n \"0.5585178\",\n \"0.55754685\",\n \"0.5555264\",\n \"0.5542493\",\n \"0.55404925\",\n \"0.5514392\",\n \"0.5394026\",\n \"0.5376499\",\n \"0.5355567\",\n \"0.53485197\",\n \"0.53262925\",\n \"0.5297183\",\n \"0.52819175\",\n \"0.52819175\",\n \"0.52819175\",\n \"0.52819175\",\n \"0.52819175\",\n \"0.52819175\",\n \"0.5280383\",\n \"0.5276791\",\n \"0.5252488\",\n \"0.52435327\",\n \"0.5237724\",\n \"0.522949\",\n \"0.5220523\",\n \"0.5218894\",\n \"0.52003044\",\n \"0.51928765\",\n \"0.5183386\",\n \"0.5178595\",\n \"0.5167659\",\n \"0.5134019\",\n \"0.5134019\",\n \"0.5133045\",\n \"0.5131466\",\n \"0.5120896\",\n \"0.51201564\",\n \"0.51201564\",\n \"0.511805\",\n \"0.5103139\",\n \"0.5096017\",\n \"0.5093936\",\n \"0.5081916\",\n \"0.5075817\",\n \"0.50745475\",\n \"0.5063044\",\n \"0.5061533\",\n \"0.50506365\",\n \"0.5037881\",\n \"0.50338906\",\n \"0.5029084\",\n \"0.502597\",\n \"0.5015943\",\n \"0.5007547\",\n \"0.5006716\",\n \"0.50061625\",\n \"0.4996792\",\n \"0.49965736\",\n \"0.4993423\",\n \"0.4993423\",\n \"0.49897972\",\n \"0.49767748\",\n \"0.49767298\",\n \"0.49757093\",\n \"0.49491033\",\n \"0.49458483\",\n \"0.4945029\",\n \"0.4944715\",\n \"0.49375892\",\n \"0.4926302\",\n \"0.49120924\",\n \"0.49114105\",\n \"0.49087328\",\n \"0.49086422\",\n \"0.4904369\",\n \"0.49017486\",\n \"0.48981065\",\n \"0.48958537\",\n \"0.48942623\",\n \"0.48942623\",\n \"0.48902318\",\n \"0.48876482\",\n \"0.48868796\",\n \"0.4871556\",\n \"0.48685995\",\n \"0.48630232\",\n \"0.4862149\",\n \"0.48573598\",\n \"0.48565975\",\n \"0.48551467\",\n \"0.48538715\",\n \"0.48445508\",\n \"0.48395744\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8290577"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":41,"numItemsPerPage":100,"numTotalItems":95772,"offset":4100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Mzc4MzAzMywic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM3ODY2MzMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.uqNmiHxTx8nEcD-BKw8pT4bkwVP468b368usy21cjtKk733aD8PsNBdRov3Ab9FhBTm-vmvEfLn8xz1dBCyyBQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
The user has a valid JWT but needs to log into this app. Do so here and return the status. | def jwt_login(request, jwt_payload):
logger.debug("Logging user in via JWT. Is Authenticated? " + str(request.user.is_authenticated))
request.session['profile'] = jwt_payload
user = django_auth.authenticate(**jwt_payload)
if user:
login(request, user)
else:
logger.debug("Could not log user in.")
return request.user.is_authenticated | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LoginCheck():\n jwt_data = get_jwt()\n if jwt_data['roles'] != 'admin':\n return jsonify(msg=\"Permission denied\"), Status.HTTP_BAD_FORBIDDEN\n\n identity = get_jwt_identity()\n if not identity:\n return jsonify({\"msg\": \"Token invalid\"}), Status.HTTP_BAD_UNAUTHORIZED\n\n data ... | [
"0.7635263",
"0.7127661",
"0.6985085",
"0.6958775",
"0.68365085",
"0.6748926",
"0.6729194",
"0.6707417",
"0.6696781",
"0.6696681",
"0.6647693",
"0.66302025",
"0.6625759",
"0.66238236",
"0.6614123",
"0.66123486",
"0.65989953",
"0.659169",
"0.6581054",
"0.6579671",
"0.6572046",... | 0.63848686 | 47 |
This will log a user out and redirect them to log in again via the AuthN server. | def logout_redirect(request):
logout(request)
# Build the URL
login_url = furl(login_redirect_url(request, next_url=request.build_absolute_uri()))
# Check for branding
if hasattr(settings, 'SCIAUTH_BRANDING'):
logger.debug('SciAuth branding passed')
# Encode it and pass it
branding = base64.urlsafe_b64encode(json.dumps(settings.SCIAUTH_BRANDING).encode('utf-8')).decode('utf-8')
login_url.query.params.add('branding', branding)
# Set the URL and purge cookies
response = redirect(login_url.url)
response.delete_cookie('DBMI_JWT', domain=dbmi_settings.JWT_COOKIE_DOMAIN)
logger.debug('Redirecting to: {}'.format(login_url.url))
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout():\n logout_user()\n return redirect(url_for('auth.index'))",
"def signout():\n session.pop('oauth2_state', None)\n session.pop('oauth2_token', None)\n session.pop('discord_user', None)\n return redirect('/')",
"def logout_user(request):\r\n # We do not log here, because we have... | [
"0.74786663",
"0.7398715",
"0.7309837",
"0.7262442",
"0.7236717",
"0.72231877",
"0.72231495",
"0.7213908",
"0.72030735",
"0.7196016",
"0.71688986",
"0.71640676",
"0.7163589",
"0.7163589",
"0.7159972",
"0.71333206",
"0.71177167",
"0.7101278",
"0.709512",
"0.7080758",
"0.706229... | 0.0 | -1 |
Author overloads `error` method for scanning and parsing. I will define separate methods. | def scan_error(self, line: int, message: str):
self.report(line, "", message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(self, error):\n pass",
"def error(self, *args, **kwargs):",
"def error(self):\n ...",
"def _error(self, token, msg):\n self._interpreter.parse_error(token, msg)\n return ParseError()",
"def error(self, message):\r\n self._construct_partial_parser().error(mes... | [
"0.72092247",
"0.69668496",
"0.68345785",
"0.67888355",
"0.6770503",
"0.670923",
"0.66309696",
"0.661976",
"0.65300286",
"0.6507165",
"0.6377651",
"0.6323891",
"0.6323672",
"0.6305191",
"0.6301589",
"0.62937343",
"0.62933636",
"0.6288595",
"0.62223047",
"0.62183744",
"0.61952... | 0.6191369 | 21 |
report a runtime error | def runtime_error(self, error: 'LoxRuntimeError'):
output = f'{error.get_message()}{os.linesep}[line {error.token.line}]'
print(output, file=sys.stderr)
self.had_runtime_error = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error():\r\n raise RuntimeError('admin ticket generator at your service')",
"def reportError(self):\n self.Q['err'].put(sys.exc_info()[:2])",
"def serious_error(self, e):\n pass",
"def error(self):\n pass",
"def unexpected_error(self, exception):",
"def error(error):\n print(... | [
"0.68166107",
"0.679111",
"0.6713061",
"0.64715713",
"0.6364697",
"0.63401216",
"0.6333252",
"0.6314151",
"0.62917364",
"0.6244229",
"0.61968243",
"0.6178209",
"0.6150258",
"0.61317104",
"0.6127837",
"0.6092866",
"0.6092197",
"0.60902953",
"0.60429615",
"0.6041189",
"0.601885... | 0.7311913 | 0 |
report a nonruntime error | def report(self, line: int, where: str, message: str):
output = f'[line {line}] Error{where}: {message}'
print(output, file=sys.stderr)
self.had_error = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unexpected_error(self, exception):",
"def report_unexpected_exception(self, *args, **kwargs):\n pass",
"def reportError(self):\n self.Q['err'].put(sys.exc_info()[:2])",
"def error(self):\n pass",
"def unexpectedException(self):",
"def serious_error(self, e):\n pass",
"def... | [
"0.72789407",
"0.7216216",
"0.7035961",
"0.7010877",
"0.69478387",
"0.6807928",
"0.68002",
"0.6673932",
"0.6667403",
"0.6664058",
"0.6661008",
"0.66161615",
"0.6548039",
"0.6492653",
"0.6476202",
"0.64534765",
"0.64285237",
"0.64251786",
"0.6421437",
"0.64072937",
"0.63590854... | 0.0 | -1 |
Use an explicit connect/quit here, as other tests use the context manager. | async def test_plain_smtp_connect(preset_client):
await preset_client.connect()
assert preset_client.is_connected
await preset_client.quit()
assert not preset_client.is_connected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connection():\r\n try:\r\n connect()\r\n except:\r\n pass\r\n print ('Unable to connect.')\r\n else:\r\n main()",
"def quit(self):\n \n if 'driver' in self.__dict__:\n self.driver.quit()\n if 'session' in self.__dict__:\n self.session.close()\n... | [
"0.6924016",
"0.65419316",
"0.6448723",
"0.6423238",
"0.6363327",
"0.6345118",
"0.62429655",
"0.62380254",
"0.62205863",
"0.6215696",
"0.61930496",
"0.6161508",
"0.61469656",
"0.614523",
"0.6138414",
"0.6116715",
"0.60803974",
"0.60480607",
"0.60480607",
"0.60480607",
"0.6048... | 0.60078937 | 22 |
Note, SMTPTimeoutError vs SMTPConnectError here depends on processing time. | async def test_connect_error_with_no_server(event_loop):
client = SMTP(hostname="127.0.0.1", port=65534, loop=event_loop)
with pytest.raises(SMTPConnectError):
await client.connect(timeout=0.1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect_smtp(self):\n smtp = None\n try:\n smtp = smtplib.SMTP(self.servername, timeout = self.timeout)\n except smtplib.SMTPException as err:\n log.critical('smtp service at {} is not currently available'.format(self.servername))\n log.critical(err)\n ... | [
"0.67359835",
"0.6397967",
"0.6189997",
"0.6074653",
"0.60194963",
"0.58749896",
"0.58332354",
"0.58151186",
"0.58065194",
"0.58065194",
"0.57931924",
"0.57492477",
"0.5701048",
"0.5651594",
"0.56239885",
"0.5590371",
"0.5548968",
"0.54814523",
"0.545041",
"0.5434488",
"0.543... | 0.59302324 | 5 |
Note, SMTPTimeoutError vs SMTPConnectError here depends on processing time. | async def test_timeout_error_with_no_server(event_loop):
client = SMTP(hostname="127.0.0.1", port=65534, loop=event_loop)
with pytest.raises(SMTPTimeoutError):
await client.connect(timeout=0.000000001) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect_smtp(self):\n smtp = None\n try:\n smtp = smtplib.SMTP(self.servername, timeout = self.timeout)\n except smtplib.SMTPException as err:\n log.critical('smtp service at {} is not currently available'.format(self.servername))\n log.critical(err)\n ... | [
"0.67359835",
"0.6189997",
"0.6074653",
"0.60194963",
"0.59302324",
"0.58749896",
"0.58332354",
"0.58151186",
"0.58065194",
"0.58065194",
"0.57931924",
"0.57492477",
"0.5701048",
"0.5651594",
"0.56239885",
"0.5590371",
"0.5548968",
"0.54814523",
"0.545041",
"0.5434488",
"0.54... | 0.6397967 | 1 |
The `data` command is a special case it access protocol directly, rather than using `execute_command`. | async def test_disconnected_server_raises_on_data_read(preset_client):
await preset_client.connect()
preset_client.server.responses.append(b"250 Hello there")
await preset_client.ehlo()
preset_client.server.responses.append(b"250 ok")
await preset_client.mail("sender@example.com")
preset_client.server.responses.append(b"250 ok")
await preset_client.rcpt("recipient@example.com")
preset_client.server.responses.append(b"354 lets go")
preset_client.server.drop_connection_after_request = b"A MESSAGE\r\n.\r\n"
with pytest.raises(SMTPServerDisconnected):
await preset_client.data("A MESSAGE")
# Verify that the connection was closed
assert not preset_client._connect_lock.locked()
assert preset_client.protocol is None
assert preset_client.transport is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def command(self, inst_data: int, buf: bytes, /) -> None:",
"def execute(self, data, options):\n raise NotImplementedError()",
"def cmd(self, data, enable):\n pass",
"def call_and_feed(cmd, data):\n p = Popen(cmd, shell=True, stdin=PIPE)\n p.stdin.write(data)\n p.stdin.close()\n ret... | [
"0.7060531",
"0.6570072",
"0.6510051",
"0.63995844",
"0.6374746",
"0.6351639",
"0.63384765",
"0.62793285",
"0.6275475",
"0.62704265",
"0.61805314",
"0.61763734",
"0.6167132",
"0.61131483",
"0.60688186",
"0.60665303",
"0.6035471",
"0.60299027",
"0.5990287",
"0.5981012",
"0.596... | 0.0 | -1 |
The `data` command is a special case it accesses protocol directly, rather than using `execute_command`. | async def test_disconnected_server_raises_on_data_write(preset_client):
await preset_client.connect()
preset_client.server.responses.append(b"250 Hello there")
await preset_client.ehlo()
preset_client.server.responses.append(b"250 ok")
await preset_client.mail("sender@example.com")
preset_client.server.responses.append(b"250 ok")
await preset_client.rcpt("recipient@example.com")
preset_client.server.responses.append(b"354 lets go")
preset_client.server.drop_connection_after_request = b"A MESS"
with pytest.raises(SMTPServerDisconnected):
await preset_client.data("A MESSAGE")
# Verify that the connection was closed
assert not preset_client._connect_lock.locked()
assert preset_client.protocol is None
assert preset_client.transport is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def command(self, inst_data: int, buf: bytes, /) -> None:",
"def cmd(self, data, enable):\n pass",
"def command(dev, code, data='', verbose=False):\n communicate(dev, a2b_hex('A' + code) + data.encode('ascii'), a2b_hex('B' + code), verbose=verbose)",
"def execute(self, data, options):\n rais... | [
"0.71024805",
"0.65037835",
"0.63819116",
"0.636673",
"0.63638586",
"0.63270706",
"0.62600714",
"0.62551844",
"0.62551564",
"0.62109536",
"0.6167672",
"0.6122832",
"0.61040425",
"0.60816944",
"0.60466945",
"0.60187083",
"0.60072166",
"0.59970105",
"0.5980538",
"0.59644943",
"... | 0.0 | -1 |
The `starttls` command is a special case it accesses protocol directly, rather than using `execute_command`. | async def test_disconnected_server_raises_on_starttls(preset_client):
await preset_client.connect()
preset_client.server.responses.append(
b"\n".join([b"250-localhost, hello", b"250-SIZE 100000", b"250 STARTTLS"])
)
await preset_client.ehlo()
preset_client.server.responses.append(b"220 begin TLS pls")
preset_client.server.drop_connection_event.set()
with pytest.raises(SMTPServerDisconnected):
await preset_client.starttls(validate_certs=False)
# Verify that the connection was closed
assert not preset_client._connect_lock.locked()
assert preset_client.protocol is None
assert preset_client.transport is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __starttls(self, keyfile=None, certfile=None):\n if not self.has_tls_support():\n raise Error(\"STARTTLS not supported by the server\")\n code, data = self.__send_command(\"STARTTLS\")\n if code != \"OK\":\n return False\n try:\n nsock = ssl.wrap_soc... | [
"0.7027462",
"0.6803335",
"0.6757425",
"0.6352501",
"0.6308599",
"0.6119223",
"0.6119223",
"0.59911376",
"0.5971303",
"0.5914122",
"0.57055014",
"0.5575204",
"0.55595917",
"0.5529245",
"0.55291855",
"0.53638923",
"0.5362069",
"0.5353421",
"0.5348377",
"0.5279511",
"0.52661175... | 0.47385627 | 67 |
Exceptions can be raised, but the context manager should handle disconnection. | async def test_context_manager_disconnect_handling(preset_server, event_loop):
preset_client = SMTP(
hostname=preset_server.hostname, port=preset_server.port, loop=event_loop
)
async with preset_client:
assert preset_client.is_connected
preset_server.responses.append(b"250 noop")
preset_server.drop_connection_event.set()
try:
await preset_client.noop()
except SMTPServerDisconnected:
pass
assert not preset_client.is_connected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connection_lost(self, exc):\n pass",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.conn.close()\n if exc_val:\n raise",
"async def __aexit__(self, exc_type, exc_value, traceback):\n\n # Close the connection\n await self.disconnect()",
"def connection... | [
"0.721711",
"0.7171181",
"0.7018697",
"0.7018545",
"0.67196554",
"0.6688977",
"0.66760486",
"0.6672632",
"0.666469",
"0.666469",
"0.666469",
"0.66525275",
"0.66458035",
"0.6639069",
"0.6637687",
"0.6637687",
"0.6637687",
"0.6637687",
"0.6625044",
"0.661997",
"0.6600019",
"0... | 0.0 | -1 |
Renders its contents to a string using the current context, allowing you to process template variables embedded in things like model content, djangoflatblocks, etc. | def render_inline(parser, token):
nodelist = parser.parse(('end_render_inline',))
parser.delete_first_token()
return RenderInlineNode(nodelist) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_string(self, template: str, **vars) -> str:",
"def render(self, template: str, **vars) -> str:",
"def _render_context(self, template, block, **context):\n return u''.join(block(template.new_context(context)))",
"def get_rendered_text(self, context):\n missing = set()\n for req... | [
"0.74136245",
"0.73672175",
"0.72275555",
"0.7093623",
"0.7001947",
"0.6995675",
"0.6968364",
"0.69323826",
"0.6897053",
"0.67660546",
"0.6755247",
"0.6604185",
"0.6604105",
"0.6596961",
"0.6593976",
"0.65834063",
"0.6507833",
"0.64963186",
"0.6459822",
"0.64542526",
"0.64530... | 0.0 | -1 |
Trivial helper for the common case where you have a dictionary and want one value | def get_key(dict, key):
return dict.get(key, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_first(my_dict: Dict) -> Any:\n return list(my_dict.values())[0]",
"def _single_getitem(self, key):\n try:\n return self._dict[key]\n except KeyError:\n return self.default",
"def safely_get_value(dct: Mapping, key: Any,\n default: Union[T, Non... | [
"0.7501027",
"0.7214503",
"0.7051891",
"0.70475656",
"0.7027528",
"0.69873375",
"0.6776066",
"0.67013735",
"0.66397923",
"0.66397923",
"0.66397923",
"0.66397923",
"0.66311496",
"0.6604605",
"0.65671986",
"0.6557712",
"0.6530084",
"0.6483239",
"0.6474412",
"0.642642",
"0.63722... | 0.5995878 | 43 |
Initializer for the Symmetric Key Registration Client | def __init__(self, mqtt_state_based_provider):
super(SymmetricKeyProvisioningDeviceClient, self).__init__(mqtt_state_based_provider)
self._polling_machine = PollingMachine(mqtt_state_based_provider) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.key = b'FSMF73R873YM187R'\n self.signer = AES.new(self.key, AES.MODE_EAX)\n self.verifier = AES.new(self.key, AES.MODE_EAX, nonce=self.signer.nonce)",
"def _init_keys(self):\n\n basic_constraints = crypto.X509Extension('basicConstraints'.encode('ascii'), Tru... | [
"0.64860773",
"0.6398895",
"0.63749385",
"0.62866133",
"0.6212949",
"0.6190224",
"0.6162016",
"0.61214364",
"0.60898226",
"0.60414624",
"0.603934",
"0.6026967",
"0.6023296",
"0.59877056",
"0.59869146",
"0.5985004",
"0.5983398",
"0.5977729",
"0.5918868",
"0.59038883",
"0.58940... | 0.0 | -1 |
Register the device with the provisioning service. This is a synchronous call, meaning that this function will not return until the registration process has completed successfully or the attempt has resulted in a failure. Before returning the client will also disconnect from the Hub. If a registration attempt is made while a previous registration is in progress it may throw an error. | def register(self):
logger.info("Registering with Hub...")
register_complete = Event()
def on_register_complete(result=None, error=None):
# This could be a failed/successful registration result from the HUB
# or a error from polling machine. Response should be given appropriately
if result is not None:
if result.status == "assigned":
logger.info("Successfully registered with Hub")
else: # There be other statuses
logger.error("Failed registering with Hub")
if error is not None: # This can only happen when the polling machine runs into error
logger.info(error)
register_complete.set()
self._polling_machine.register(callback=on_register_complete)
register_complete.wait() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_device():\n payload = request.get_json()\n return _register_device(payload)",
"def RegisterDeviceAndSendResponse(self, msg, username):\n device_id = self.GetUniqueParam('deviceid')\n if not device_id:\n return (400, 'Missing device identifier')\n\n token_info = self.server.Regist... | [
"0.7048597",
"0.6574808",
"0.63383627",
"0.6312321",
"0.6306717",
"0.6257553",
"0.6199068",
"0.61455584",
"0.60931623",
"0.60073423",
"0.5975581",
"0.5859668",
"0.57837015",
"0.57369715",
"0.57089573",
"0.5657908",
"0.5651063",
"0.56088966",
"0.55459535",
"0.5511144",
"0.5496... | 0.7058231 | 0 |
This is a synchronous call, meaning that this function will not return until the cancellation process has completed successfully or the attempt has resulted in a failure. Before returning the client will also disconnect from the Hub. In case there is no registration in process it will throw an error as there is no registration process to cancel. | def cancel(self):
logger.info("Cancelling the current registration process")
cancel_complete = Event()
def on_cancel_complete():
cancel_complete.set()
logger.info("Successfully cancelled the current registration process")
self._polling_machine.cancel(callback=on_cancel_complete)
cancel_complete.wait() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disconnect(self):\n if self.is_connected:\n try:\n self.client.unregister()\n finally:\n if self.client.is_running:\n self.client.stop()\n self.hub.disconnect()",
"async def async_cancel(self):\n raise NotImpl... | [
"0.561611",
"0.53545636",
"0.53502023",
"0.52480394",
"0.5240914",
"0.5077308",
"0.50643533",
"0.49984068",
"0.49921355",
"0.498722",
"0.49676874",
"0.49660704",
"0.49642637",
"0.49493033",
"0.49309194",
"0.49151906",
"0.4906097",
"0.4895857",
"0.48792404",
"0.48342264",
"0.4... | 0.6079265 | 0 |
read dataset from file | def read_data(self, filepath, is_build_vocab=False):
with open("general_list.pkl", "rb") as file:
self.general_list = pl.load(file)
self.vocab.token2idx = {"<pad>": 0, "<unk>": 1}
print(len(self.general_list))
ll = 2
for token in self.general_list:
self.vocab.token2idx[token] = ll
ll+=1
print("max id", max(list(self.vocab.token2idx.values())), len(self.vocab.token2idx))
self.vocab.idx2token = {idx: token for token, idx in self.vocab.token2idx.items()}
#print("max_len", self.vocab.token2idx)
datas = []
with open(filepath, "r", encoding="utf-8") as reader:
for line in reader:
line = line.strip()
if not line:
continue
obj = json.loads(line)
datas.append(obj)
return datas | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_dataset(file_path):\n return Dataset.load(file_path)",
"def open_file(path):\n input_file = os.path.join(path)\n with open(input_file) as f:\n dataset = f.read()\n return dataset",
"def import_dataset(fpath):\r\n data = read_csv(fpath)\r\n print(data.head())\r\n print(data.... | [
"0.7562527",
"0.7480861",
"0.7459469",
"0.7441094",
"0.7441094",
"0.7398603",
"0.73654073",
"0.72704476",
"0.72160506",
"0.7185216",
"0.7167113",
"0.7102375",
"0.7040365",
"0.7037207",
"0.7018122",
"0.70112073",
"0.69961697",
"0.69836414",
"0.6924565",
"0.69151974",
"0.685023... | 0.0 | -1 |
Ask a yes/no/quit question via raw_input() and return their answer. "question" is a string that is presented to the user. "default" is the presumed answer if the user just hits . It must be "yes" (the default), "no", "quit" or None (meaning an answer is required of the user). The "answer" return value is one of "yes", "no" or "quit". | def query_yes_no_quit(question, default="yes"):
valid = {"yes":"yes", "y":"yes", "ye":"yes", "no":"no", "n":"no", "quit":"quit", "qui":"quit", "qu":"quit", "q":"quit"}
if default == None:
prompt = " [y/n/q] "
elif default == "yes":
prompt = " [Y/n/q] "
elif default == "no":
prompt = " [y/N/q] "
elif default == "quit":
prompt = " [y/n/Q] "
else:
raise ValueError("invalid default answer: '%s'" % default)
while 1:
sys.stdout.write(question + prompt)
choice = raw_input().lower()
if default is not None and choice == '':
return default
elif choice in valid.keys():
return valid[choice]
else:
sys.stdout.write("Please respond with 'yes', 'no' or 'quit'.\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_yes_no_quit(question, default=\"yes\"):\n valid = {\"yes\":\"yes\", \"y\":\"yes\", \"ye\":\"yes\",\n \"no\":\"no\", \"n\":\"no\",\n \"quit\":\"quit\", \"qui\":\"quit\", \"qu\":\"quit\", \"q\":\"quit\"}\n if default == None:\n prompt = \" [y/n/q] \"\n elif ... | [
"0.8437878",
"0.8223772",
"0.8212373",
"0.8156623",
"0.8149691",
"0.81355673",
"0.81233436",
"0.8122114",
"0.8120957",
"0.8120957",
"0.8120957",
"0.8120957",
"0.8120957",
"0.8120957",
"0.8120957",
"0.8120957",
"0.81196237",
"0.81192315",
"0.81192315",
"0.81192315",
"0.8119231... | 0.834716 | 1 |
Returns the url to access a detail record for this book. | def get_absolute_url(self):
return reverse("mountain", args=[str(self.state_name), str(self.name)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_absolute_url(self):\n return reverse('book-detail', args=[str(self.id)]) \n # Returns an URL that can be used to access a detail record for this model \n # (for this to work we will have to \n # -- Define a URL mapping that has the name 'book-detail' (name='book-detail')\n ... | [
"0.76990575",
"0.7611185",
"0.7257499",
"0.7257499",
"0.7257499",
"0.7117704",
"0.6992158",
"0.69547594",
"0.6935497",
"0.684423",
"0.6591669",
"0.6543265",
"0.6541738",
"0.64656514",
"0.6445659",
"0.64323515",
"0.64318234",
"0.6417527",
"0.6407866",
"0.638662",
"0.6367192",
... | 0.0 | -1 |
Loads directly from a joint/pose/match network's stored checkpoint | def load_weights(self, state_dict):
own_state = self.state_dict()
# Copy the convloutional layers
for name, param in state_dict.iteritems():
if 'base_conv' in name:
own_state[name].copy_(param)
# Convert the FC layers to convolutional layers
own_state['base_fc.0.weight'].copy_(state_dict['base_fc.0.weight'].view(500, 160, 3, 3))
own_state['base_fc.0.bias'].copy_(state_dict['base_fc.0.bias'])
own_state['base_fc.2.weight'].copy_(state_dict['base_fc.2.weight'].view(500, 500, 1, 1))
own_state['base_fc.2.bias'].copy_(state_dict['base_fc.2.bias'])
# Freeze the weights for the initial Conv and FC layers
for i in range(len(self.base_conv)):
if hasattr(self.base_conv[i], 'weight'):
self.base_conv[i].weight.requires_grad = False
if hasattr(self.base_conv[i], 'bias'):
self.base_conv[i].bias.requires_grad = False
for i in range(len(self.base_fc)):
if hasattr(self.base_fc[i], 'weight'):
self.base_fc[i].weight.requires_grad = False
if hasattr(self.base_fc[i], 'bias'):
self.base_fc[i].bias.requires_grad = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)",
"def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_na... | [
"0.7687991",
"0.76203847",
"0.7493186",
"0.74810845",
"0.74057525",
"0.7371094",
"0.7363626",
"0.7347734",
"0.72986746",
"0.7289724",
"0.7277159",
"0.7276603",
"0.72691387",
"0.72505075",
"0.7244596",
"0.7222293",
"0.7212705",
"0.72107184",
"0.72104317",
"0.7187941",
"0.71760... | 0.0 | -1 |
Creates invoice related analytics and financial move lines | def action_move_create(self):
account_move = self.env['account.move']
for inv in self:
if not inv.journal_id.sequence_id:
raise UserError(_('Please define sequence on the journal related to this invoice.'))
if not inv.invoice_line_ids.filtered(lambda line: line.account_id):
raise UserError(_('Please add at least one invoice line.'))
if inv.move_id:
continue
if not inv.date_invoice:
inv.write({'date_invoice': fields.Date.context_today(self)})
if not inv.date_due:
inv.write({'date_due': inv.date_invoice})
company_currency = inv.company_id.currency_id
# create move lines (one per invoice line + eventual taxes and analytic lines)
iml = inv.invoice_line_move_line_get()
iml += inv.tax_line_move_line_get()
diff_currency = inv.currency_id != company_currency
# create one move line for the total and possibly adjust the other lines amount
total, total_currency, iml = inv.compute_invoice_totals(company_currency, iml)
name = inv.name or ''
if inv.payment_term_id:
totlines = inv.payment_term_id.with_context(currency_id=company_currency.id).compute(total, inv.date_invoice)[0]
res_amount_currency = total_currency
for i, t in enumerate(totlines):
if inv.currency_id != company_currency:
amount_currency = company_currency._convert(t[1], inv.currency_id, inv.company_id, inv._get_currency_rate_date() or fields.Date.today())
else:
amount_currency = False
# last line: add the diff
res_amount_currency -= amount_currency or 0
if i + 1 == len(totlines):
amount_currency += res_amount_currency
_logger.info(inv)
iml.append({
'type': 'dest',
'name': name,
'price': t[1],
'account_id': inv.account_id.id,
'date_maturity': t[0],
'amount_currency': diff_currency and amount_currency,
'currency_id': diff_currency and inv.currency_id.id,
'invoice_id': inv.id,
#'partner_id': inv.partner_line_id.id
})
else:
_logger.info(inv)
total_taxes_to_pay = self.return_tax_to_payy()
if inv.taxes_collected_id.type_taxes == 'tax_company':
iml.append({
'type': 'dest',
'name': name,
'price': total_taxes_to_pay,
'account_id': inv.taxes_collected_id.account_id.id,
'date_maturity': inv.date_due,
'amount_currency': diff_currency and total_currency,
'currency_id': diff_currency and inv.currency_id.id,
'invoice_id': inv.id,
#'partner_id': inv.partner_line_id.id
})
iml.append({
'type': 'dest',
'name': name,
'price': total- total_taxes_to_pay,
'account_id': inv.account_id.id,
'date_maturity': inv.date_due,
'amount_currency': diff_currency and total_currency,
'currency_id': diff_currency and inv.currency_id.id,
'invoice_id': inv.id,
#'partner_id': inv.partner_line_id.id
})
else:
iml.append({
'type': 'dest',
'name': name,
'price': total,
'account_id': inv.account_id.id,
'date_maturity': inv.date_due,
'amount_currency': diff_currency and total_currency,
'currency_id': diff_currency and inv.currency_id.id,
'invoice_id': inv.id,
#'partner_id': inv.partner_line_id.id
})
part = self.env['res.partner']._find_accounting_partner(inv.partner_id)
#validamo que sea una factura de proveedor
if self.type == 'in_invoice':
data_new = []
for l in iml:
if 'partner_id' in l:
if l['partner_id']:
data_new.append((0, 0, self.line_get_convert(l, l['partner_id'])) )
else:
data_new.append((0, 0, self.line_get_convert(l, part.id)) )
line = [l for l in data_new ]
else:
line = [(0, 0, self.line_get_convert(l, part.id)) for l in iml ]
line = inv.group_lines(iml, line)
line = inv.finalize_invoice_move_lines(line)
date = inv.date or inv.date_invoice
move_vals = {
'ref': inv.reference,
'line_ids': line,
'journal_id': inv.journal_id.id,
'date': date,
'narration': inv.comment,
}
move = account_move.create(move_vals)
# Pass invoice in method post: used if you want to get the same
# account move reference when creating the same invoice after a cancelled one:
move.post(invoice = inv)
# make the invoice point to that move
vals = {
'move_id': move.id,
'date': date,
'move_name': move.name,
}
inv.write(vals)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_invoice(self):\n self.ensure_one()\n partner = self.member_id.partner_id\n invoice = self.env['account.invoice'].create({\n 'partner_id': partner.id,\n 'account_id': partner.property_account_receivable_id.id,\n 'fiscal_position_id': partner.property... | [
"0.74461937",
"0.7406681",
"0.70905787",
"0.7032683",
"0.69090813",
"0.68788975",
"0.6871585",
"0.68584",
"0.68474764",
"0.68273807",
"0.6741477",
"0.6672866",
"0.6667218",
"0.65647554",
"0.65585667",
"0.63950473",
"0.6327984",
"0.6303532",
"0.6284394",
"0.6256989",
"0.623792... | 0.65702105 | 13 |
Compute the mean absolute error on test set given X, y, and model parameter w. | def mean_absolute_error(w, X, y):
#####################################################
# TODO 1: Fill in your code here #
#####################################################
err = None
temp = np.dot(X, w)
err = np.mean(np.abs(_error(y, temp)))
return err | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_absolute_error(w, X, y):\n #####################################################\n # TODO 1: Fill in your code here #\n #####################################################\n if w is None:\n return None\n\n err = None\n yhat = np.dot(X , w)\n err = np.abs(np.subtract(yhat,y)).... | [
"0.77339864",
"0.76291317",
"0.7148356",
"0.7034834",
"0.68424296",
"0.67941666",
"0.66706353",
"0.6591392",
"0.6557777",
"0.6557774",
"0.6482599",
"0.6372792",
"0.63640726",
"0.6351532",
"0.63476115",
"0.63377297",
"0.63268167",
"0.6277267",
"0.6224823",
"0.61900854",
"0.616... | 0.7912273 | 0 |
Compute the weight parameter given X and y. | def linear_regression_noreg(X, y):
#####################################################
# TODO 2: Fill in your code here #
#####################################################
temp = X.T
result = np.dot(temp, X)
result = np.linalg.inv(result)
result = np.dot(result, temp)
w = np.dot(result, y)
return w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weight(self, y, xn, xo):\n\n return self._model.log_prob(y, xn) + self._model.h_weight(xn, xo) - self._kernel.log_prob(xn)",
"def compute_weight(self, y, x, test_x=None, test_y=None, **kwargs):\n model = copy.copy(self)\n model.__setattr__('train_y', y)\n model.__setattr__('train_... | [
"0.7623957",
"0.7152357",
"0.687893",
"0.68283564",
"0.6542995",
"0.64705515",
"0.6444899",
"0.64352334",
"0.63989145",
"0.63828194",
"0.6370652",
"0.63449967",
"0.63418835",
"0.6321859",
"0.6318847",
"0.6310803",
"0.6279792",
"0.62733525",
"0.62622386",
"0.62539375",
"0.6229... | 0.0 | -1 |
Compute the weight parameter given X and y. | def linear_regression_invertible(X, y):
#####################################################
# TODO 3: Fill in your code here #
#####################################################
w = None
X_X_T = np.dot(X.T, X)
ev = 0
while ev < (10**-5):
ev = np.min((np.linalg.eig(X_X_T)[0]))
if ev < (10**-5):
X_X_T = X_X_T + (10**-1) * np.identity(X_X_T.shape[0])
w = np.dot(np.dot(np.linalg.inv(X_X_T), X.T), y)
return w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weight(self, y, xn, xo):\n\n return self._model.log_prob(y, xn) + self._model.h_weight(xn, xo) - self._kernel.log_prob(xn)",
"def compute_weight(self, y, x, test_x=None, test_y=None, **kwargs):\n model = copy.copy(self)\n model.__setattr__('train_y', y)\n model.__setattr__('train_... | [
"0.7623957",
"0.7152357",
"0.687893",
"0.68283564",
"0.6542995",
"0.64705515",
"0.6444899",
"0.64352334",
"0.63989145",
"0.63828194",
"0.6370652",
"0.63449967",
"0.63418835",
"0.6321859",
"0.6318847",
"0.6310803",
"0.6279792",
"0.62733525",
"0.62622386",
"0.62539375",
"0.6229... | 0.0 | -1 |
Compute the weight parameter given X, y and lambda. | def regularized_linear_regression(X, y, lambd):
#####################################################
# TODO 4: Fill in your code here #
#####################################################
w = None
X_X_T = np.dot(X.T, X)
X_X_T += lambd * np.identity(X_X_T.shape[0])
w = np.dot(np.dot(np.linalg.inv(X_X_T), X.T), y)
return w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def value(a, y, weights, lambda_):\n\t\treturn 0.5* (np.linalg.norm(a-y)**2) / (a.shape[0] * a.shape[1])\n\t\t# return unregularize + (0.5*lambda_*np.sum(np.square(weights[-1])) / (a.shape[0] * a.shape[1])) ",
"def value(a, y, weights, lambda_):\n\t\treturn np.sum(np.nan_to_num(-y*np.log(a + 1e-15)-(1-y)*np.log(... | [
"0.7590008",
"0.6892587",
"0.6760674",
"0.66900504",
"0.6663615",
"0.6605572",
"0.65382785",
"0.65217125",
"0.64970404",
"0.64742047",
"0.64711386",
"0.6437741",
"0.6418927",
"0.63539314",
"0.6347361",
"0.63001853",
"0.6257059",
"0.62478036",
"0.62149435",
"0.6209357",
"0.616... | 0.0 | -1 |
Find the best lambda value. | def tune_lambda(Xtrain, ytrain, Xval, yval):
#####################################################
# TODO 5: Fill in your code here #
#####################################################
bestlambda = None
err = 1
for v in range(-19,20):
if v>=0:
val = float("1e+"+str(v))
else:
val = float("1e"+str(v))
w = regularized_linear_regression(Xtrain,ytrain, val)
error = mean_absolute_error(w, Xval,yval)
if err > error:
err = error
bestlambda = val
return bestlambda | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lambda(model):\n best_lambdas = [1000.0, 0.001, 100.0, 0.001, 100.0, 100.0, 0.001, 100.0]\n lambda_ = best_lambdas[model]\n return lambda_",
"def __bestLambda(self):\n\t\t\n\t\t# Determine starting value for brent-method (to avoid local minimum).\n\t\tself.startValue = self.__findStartValue()\n\... | [
"0.74376184",
"0.71890557",
"0.655791",
"0.6550202",
"0.63085747",
"0.6219973",
"0.6184345",
"0.61574817",
"0.6153785",
"0.61114615",
"0.6099454",
"0.60798913",
"0.6037426",
"0.6037426",
"0.6017245",
"0.5970384",
"0.58916986",
"0.58453995",
"0.5843659",
"0.5816554",
"0.578878... | 0.6234567 | 5 |
r"""Convert ratio to decibels. Converting a ratio to decibels depends on whether the ratio is a ratio of amplitudes or a ratio of powers. For amplitudes the decibel value is | def dB(x, power=False):
if power:
return 10 * np.log10(np.abs(x))
else:
return 20 * np.log10(np.abs(x)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decibel(x):\n return 10.0 * np.log10(x)",
"def idecibel(x):\n return 10.0 ** (x / 10.0)",
"def _bcd2dec(self, value):\n return ((value >> 4) * 10) + (value & 0x0F)",
"def ppcm_denominateurs(self):\n\t\tl = []\n\t\tn = 1\n\t\tif self.__valide:\n\t\t\tfor m in self.liste_decroissante():\n\t\t\... | [
"0.5972083",
"0.58928466",
"0.5669203",
"0.56526047",
"0.55357",
"0.55007315",
"0.5486681",
"0.54774976",
"0.544386",
"0.5438974",
"0.53794795",
"0.53770524",
"0.53531665",
"0.52374",
"0.5221092",
"0.51855433",
"0.5179858",
"0.5170302",
"0.51680213",
"0.5166022",
"0.51482767"... | 0.4874277 | 42 |
Iterate over orders. Iterator to iterate over the orders in the indexer. Will enable the synchronized `modes` iterator. | def orders(self):
self._current_order = self.min_order
while self._current_order <= self.max_order:
yield self._current_order
self._current_order += 1
del self._current_order | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modes(self):\n try:\n order = self._current_order\n except AttributeError:\n raise AttributeError('Cannot iterate over modes without iterating over orders!') from None\n mode = -order\n while mode <= order:\n yield mode\n mode += 1",
"de... | [
"0.67183816",
"0.6654742",
"0.6436368",
"0.6087598",
"0.59756845",
"0.5863205",
"0.5597003",
"0.55368114",
"0.5527949",
"0.5482221",
"0.547718",
"0.5439024",
"0.54328644",
"0.543001",
"0.53729576",
"0.53424174",
"0.53381103",
"0.5320791",
"0.5310121",
"0.52943534",
"0.5290345... | 0.58461016 | 6 |
Iterate over modes. Synchronized iterator to iterate the modes in an order. | def modes(self):
try:
order = self._current_order
except AttributeError:
raise AttributeError('Cannot iterate over modes without iterating over orders!') from None
mode = -order
while mode <= order:
yield mode
mode += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n return iter([v for k, v in sorted(self._modes.items())])",
"def get_modes(self):\n return [i for i, j in enumerate(self._modemap._map) if j is not None]",
"async def _load_modes(self) -> None:\n modes: List[Dict[str, Any]] = await self._api_request(\"modes\")\n ... | [
"0.7799798",
"0.63018954",
"0.6299035",
"0.62619734",
"0.62619734",
"0.6169084",
"0.61189497",
"0.60541093",
"0.5993781",
"0.5993781",
"0.59646934",
"0.58745813",
"0.58432204",
"0.58386713",
"0.5829693",
"0.57918906",
"0.57898873",
"0.57819664",
"0.5591517",
"0.5588966",
"0.5... | 0.78386045 | 0 |
Sum spherical harmonics coefficients of the same order. Calculates the sum of the coefficients for all modes for each order individually. The `SphericalHarmonicsIndexer` needs to be created to match the orders of the expansion coefficients. This requires that the length of the summation axis is the same as the number of coefficients for the orders specified, i.e. `values.shape[axis] == len(self)`. If no axis is specified, the first suitable axis will be used. | def ordersum(self, values, axis=None):
values = np.asarray(values)
if axis is None:
for axis in range(values.ndim):
if values.shape[axis] == len(self):
break
else:
raise ValueError('Cannot find axis of length {} in the given values!'.format(len(self)))
values = np.moveaxis(values, axis, 0)
output = np.zeros((self.max_order - self.min_order + 1, ) + values.shape[1:], dtype=values.dtype)
for idx, order in enumerate(self.orders):
output[idx] = np.sum(values[self(order, -order):self(order, order) + 1], axis=0)
return np.moveaxis(output, 0, axis) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _harmonic_sum(self, rank: int) -> complex:\n return (self.flm * self.slepian.eigenvectors[rank].conj()).sum()",
"def sum(self, axis: int = 0):\r\n self.values = self.values.sum(axis=axis)\r\n self.layers = [None]\r\n return self.copy()",
"def sh( values ):\n # ECMWF normalize... | [
"0.60549116",
"0.5197901",
"0.51612186",
"0.5089202",
"0.5049697",
"0.49782285",
"0.49448317",
"0.4918859",
"0.49002635",
"0.48757395",
"0.48220482",
"0.47755814",
"0.47722915",
"0.47557205",
"0.4742954",
"0.4741564",
"0.4729267",
"0.47249097",
"0.4709373",
"0.47004437",
"0.4... | 0.5082671 | 4 |
r"""Find the approximate location of a levitation trap. Find an approximate position of a acoustic levitation trap close to a starting point. This is done by following the radiation force in the sound field using an differential equation solver. The differential equation is the unphysical equation | def find_trap(array, start_position, complex_transducer_amplitudes, tolerance=10e-6, time_interval=50, path_points=1, **kwargs):
from scipy.integrate import solve_ivp
from numpy.linalg import lstsq
if 'radius' in kwargs:
from .fields import SphericalHarmonicsForce as Force, SphericalHarmonicsForceGradient as ForceGradient
else:
from .fields import RadiationForce as Force, RadiationForceGradient as ForceGradient
evaluator = Force(array, **kwargs) + ForceGradient(array, **kwargs)
mg = evaluator.fields[0].field.mg
def f(t, x):
F = evaluator(complex_transducer_amplitudes, x)[0]
F[2] -= mg
return F
def bead_close(t, x):
F, dF = evaluator(complex_transducer_amplitudes, x)
F[2] -= mg
dx = lstsq(dF, F, rcond=None)[0]
distance = np.sum(dx**2, axis=0)**0.5
return np.clip(distance - tolerance, 0, None)
bead_close.terminal = True
outs = solve_ivp(f, (0, time_interval), np.asarray(start_position), events=bead_close, vectorized=True, dense_output=path_points > 1)
if outs.message != 'A termination event occurred.':
print('End criterion not met. Final path position might not be close to trap location.')
if path_points > 1:
return outs.sol(np.linspace(0, outs.sol.t_max, path_points))
else:
return outs.y[:, -1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\... | [
"0.5917251",
"0.5454485",
"0.53869474",
"0.53047276",
"0.5189361",
"0.51892936",
"0.5161829",
"0.5157585",
"0.51523453",
"0.51253486",
"0.51195055",
"0.5104085",
"0.5075305",
"0.5061984",
"0.50457203",
"0.50427437",
"0.50212985",
"0.49925196",
"0.498679",
"0.49814695",
"0.497... | 0.63866895 | 0 |
Do an internal (non302) redirect to the front page. Preserves the user agent's requested URL. | def show_main_page(request, error_msg=None):
request.method='GET'
return MainPage(request, error_msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home_page():\n return redirect(url_for(_DEFAULT_ROUTE, _external=True))",
"def root_redirect():\r\n return redirect(url_for(\"display_top\"))",
"def redirect(url):",
"def redirect(self, url):\n raise RequestRedirect(url)",
"def redirect(uri):\n response = HttpResponse('', status=302)\n ... | [
"0.69821596",
"0.6857515",
"0.68187505",
"0.65282667",
"0.65206647",
"0.64767575",
"0.6462469",
"0.6432681",
"0.6411949",
"0.63972974",
"0.6323725",
"0.63229686",
"0.6311373",
"0.63092226",
"0.62773234",
"0.6263432",
"0.625649",
"0.625649",
"0.6236038",
"0.6210916",
"0.61977"... | 0.0 | -1 |
Return criteria given by user and the column in the database it refers to. | def select():
file_title, song_title = [None, None], [None, None]
artist, data, tag, form = [None, None], [None, None], [None, None], [None, None]
while True:
file_title[0] = input("Would you like to select by file name?[Y/N]\t")
if file_title[0] == 'Y':
file_title[1] = input("Give file name:\t")
break
elif file_title[0] == 'N':
break
else:
print("Unknown answer. Please respond with Y or N...")
while True:
song_title[0] = input("Would you like to select by song title?[Y/N]\t")
if song_title[0] == 'Y':
song_title[1] = input("Give song title:\t")
break
elif song_title[0] == 'N':
break
else:
print("Unknown answer. Please respond with Y or N...")
while True:
artist[0] = input("Would you like to select by artist?[Y/N]\t")
if artist[0] == 'Y':
artist[1] = input("Give artist name:\t")
break
elif artist[0] == 'N':
break
else:
print("Unknown answer. Please respond with Y or N...")
while True:
data[0] = input("Would you like to select by release date?[Y/N]\t")
if data[0] == 'Y':
data[1] = input("Give release date:\t")
break
elif data[0] == 'N':
data[1] = None
break
else:
print("Unknown answer. Please respond with Y or N...")
while True:
tag[0] = input("Would you like to select by tags?[Y/N]\t")
if tag[0] == 'Y':
tag[1] = input("Give a tag:\t")
break
elif tag[0] == 'N':
tag[1] = None
break
else:
print("Unknown answer. Please respond with Y or N...")
while True:
form[0] = input("Would you like to select by format?[Y/N]\t")
if form[0] == 'Y':
form[1] = input("Give format:\t")
break
elif form[0] == 'N':
form[1] = None
break
else:
print("Unknown answer. Please respond with Y or N...")
where = "" # Saves the where-clause for the database interrogation
criteria = tuple() # Saves the criteria given by the user
if file_title[0] == 'Y':
where += nameof(file_title) + " = %s AND "
criteria += (file_title[1],)
if song_title[0] == 'Y':
where += nameof(song_title) + " = %s AND "
criteria += (song_title[1],)
if artist[0] == 'Y':
where += nameof(artist) + " = %s AND "
criteria += (artist[1],)
if data[0] == 'Y':
where += nameof(data) + " = %s AND "
criteria += (data[1],)
if tag[0] == 'Y':
where += nameof(tag) + " LIKE %s AND "
criteria += ("%" + tag[1] + "%",)
if form[0] == 'Y':
where += nameof(artist) + " = %s AND "
criteria += (form[1],)
return criteria, where | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_column_with_constraint(db, table, column, condition_col, condition_val):\n condition = condition_col + \" = '\" + str(condition_val) + \"'\"\n result = select_columns(db, table, column, condition=condition)\n\n return result",
"def get_criteria(self):\n\n\t\treturn self.__criteria",
"def ge... | [
"0.5852314",
"0.57501423",
"0.5629169",
"0.5598633",
"0.5358296",
"0.5331501",
"0.5246509",
"0.52190596",
"0.5164159",
"0.51409566",
"0.50485057",
"0.50430083",
"0.50312936",
"0.503079",
"0.5022927",
"0.49895406",
"0.49535307",
"0.49471778",
"0.49386907",
"0.49316448",
"0.491... | 0.0 | -1 |
Initialization of the tool Make database and table and connect to the database | def __init__(self):
self.cnx = mysql.connector.connect(user='root', password='',
host='127.0.0.1',
database='songstorage') # Connect to mySQL, username root, password none
self.cursor = self.cnx.cursor() # Initialize the mySQL cursor
self.cursor.execute("SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'songstorage'"
" AND table_name = 'songs'") # Check the existence of the table
result = self.cursor.fetchall()
if result[0][0] == 0:
self.cursor.execute(
"CREATE TABLE songs (ID INT NOT NULL AUTO_INCREMENT, file_title VARCHAR(255), song_title VARCHAR("
"255), artist VARCHAR(255), form VARCHAR(255), data VARCHAR(255), tag VARCHAR(255), PRIMARY KEY ("
"ID))") # Create the table if it doesn't already exist
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_db(self):\n cursor = self._main_connection.cursor()\n cursor.execute(self.sql[\"create_table\"])\n self._main_connection.commit()",
"def create_db(self):",
"def setdb():\n\n if not database_exists(DB_URL):\n print('Creating database.')\n create_database(DB_URL)\n... | [
"0.7486164",
"0.7400551",
"0.7391027",
"0.73457515",
"0.7313018",
"0.726847",
"0.7231708",
"0.71860963",
"0.7173379",
"0.71718526",
"0.7118039",
"0.7113357",
"0.7111005",
"0.7111005",
"0.7058268",
"0.70503473",
"0.70164067",
"0.6996071",
"0.6991648",
"0.69865584",
"0.6979697"... | 0.0 | -1 |
Waits for a command and calls the right function. | def start_tool(self):
while True:
com = input("Give a command. Type H for help...:\t ").lower() # Receive a command from the user
if com == 'h':
print('Available commands: H, Exit, Play, Stop, Pause, Add_song, Delete_song, Modify_data, '
'Create_save_list, Search')
elif com == 'exit':
if self.isPlaying: # Check if there's any song playing or paused and stop it before exiting
self.isPlaying = False
self.playSong[0].stop()
self.playSong.clear()
print("Exiting...")
break
elif com == 'play':
if not self.isPlaying: # Play the song if none is currently paused
self.play_song()
else:
stop = input(
"There is a song paused or currently playing. Do you want to stop it and play another song? ["
"Y/N]\t").lower()
while True:
if stop == 'n':
print("The song current song will be resumed...")
self.playSong[0].play() # Resume the paused song
break
elif stop == 'y':
self.stop_song() # Stop the paused song
self.play_song() # Play another song
break
else:
print("Unknown command. Please answer with Y or N...")
elif com == 'stop':
self.stop_song()
elif com == 'pause':
self.pause_song()
elif com == 'add_song':
print(self.add_song())
elif com == 'delete_song':
self.delete_song()
elif com == 'modify_data':
self.modify_data()
elif com == "create_save_list":
self.create_save_list()
elif com == "search":
self.search()
else:
print("Unknown command. Try again...") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_command(command):\n send_command(command)\n # time.sleep(0.1) # may be required on slow machines\n response = get_response()\n print(\"Rcvd: <<< \" + response)\n return response",
"def _execute(self):\n LOG.info(\"Waiting for a message...\")",
"def execute_command_async(self, comma... | [
"0.6850583",
"0.6637179",
"0.66318923",
"0.66277975",
"0.65436953",
"0.64919645",
"0.64890045",
"0.6457957",
"0.6421299",
"0.63659066",
"0.63242984",
"0.62695634",
"0.62560266",
"0.6223955",
"0.62138736",
"0.61878145",
"0.61755884",
"0.6169835",
"0.6162347",
"0.6137532",
"0.6... | 0.0 | -1 |
Play a song based on its path. | def play_song(self):
path = input('Give path to wanted song: ') # Request path to song
path = path.replace('\\', '/')
if not self.path_storage_re.match(path): # Check if the wanted song is from the storage directory
print("Give a valid path")
else:
p = vlc.MediaPlayer(path) # Create VLC instance and play the song
p.play()
self.playSong.append(p)
self.isPlaying = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play(path):\n sound = AudioSegment.from_mp3(path)\n playback.play(sound)",
"def play(self, songpos=None):\n # TODO: implement songpos !\n if songpos is None:\n resp = yield from self.command('play')\n return True",
"def play(song):\n # Show the metadata\n if (ver... | [
"0.79737085",
"0.68196875",
"0.66903174",
"0.66628766",
"0.65618736",
"0.6544999",
"0.648962",
"0.64856863",
"0.6419521",
"0.6384046",
"0.6374167",
"0.633997",
"0.63393456",
"0.63371986",
"0.63166153",
"0.6316028",
"0.6295789",
"0.6295789",
"0.62778527",
"0.6240952",
"0.62402... | 0.8189756 | 0 |
Stop the current playing/paused song. | def stop_song(self):
if self.isPlaying:
self.playSong[0].stop()
self.playSong.clear()
self.isPlaying = False
print("Music stopped")
else:
print("Play a song first...") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _stop(self, ctx: commands.Context):\n ctx.voice_state.songs.clear()\n\n if ctx.voice_state.is_playing:\n ctx.voice_state.voice.stop()\n return await ctx.send(embed=embed_msg(description=\"🛑 Stopped the music\"))\n\n else:\n return await ctx.send('Can... | [
"0.7680431",
"0.76113164",
"0.759389",
"0.75338066",
"0.75338066",
"0.7464192",
"0.74512273",
"0.7417875",
"0.7278527",
"0.71976995",
"0.71916264",
"0.7135208",
"0.710452",
"0.69504833",
"0.6907551",
"0.68905944",
"0.6856153",
"0.6830112",
"0.68043816",
"0.6791049",
"0.675709... | 0.81801236 | 0 |
Pause the current playing song. | def pause_song(self):
if self.isPlaying:
self.playSong[0].pause()
print("Song paused. To continue type Play.")
else:
print("Play a song first...") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pause(self):\n self.paused = True\n # FIXME?: Why is this not doing anything? Shouldn't it be calling into the player API?",
"def pause(self):\n if not self.paused:\n pygame.mixer.music.pause()\n self.paused = True\n else:\n pygame.mixer.music.un... | [
"0.7713319",
"0.74910986",
"0.74175787",
"0.7405902",
"0.7326798",
"0.72035414",
"0.71642816",
"0.71472704",
"0.7133736",
"0.7114518",
"0.70905143",
"0.7087032",
"0.7062801",
"0.70473045",
"0.70375997",
"0.70167387",
"0.70167387",
"0.6942558",
"0.6881331",
"0.6881242",
"0.683... | 0.82099915 | 0 |
Add song to the storage directory and to the database. Return ID of the new song / error message. | def add_song(self):
path = input("Give file path:\t") # Request file path
path = path.replace('\\', '/')
if self.path_song_re.match(path) and not self.path_storage_re.match(
path): # Check that the path leads to a song that is not already found in Storage
copy(path, self.p_storage) # Copy the song to the storage directory
file_title, form = path.split("/")[-1].split(".") # Save file title and format from the path
sql = "SELECT COUNT(*) FROM songs WHERE file_title = %s AND form = %s" # Check the existence of a song
# with the same title and format in the database
self.cursor.execute(sql, (file_title, form))
r = self.cursor.fetchall()
if r[0][0] != 0:
return "A song with this file name and format already exists!"
song_title = input("Song title:\t")
artist = input("Artist:\t")
data = input("Release date:\t")
tags = input("Associated tags:\t")
sql = "INSERT INTO songs (file_title, song_title, artist, form, data, tag) VALUES (%s, %s, %s, %s, %s, " \
"%s) " # Insert song into database
columns = (file_title, song_title, artist, form, data, tags)
self.cursor.execute(sql, columns)
self.cnx.commit()
self.cursor.execute(
"SELECT MAX(ID) FROM songs")
result = self.cursor.fetchall()
return "New song ID: " + str(result[0][0])
else:
return "Give valid path" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_song():\n options = queue.instantiate_options()\n raw_queue = queue.instantiate_queue()\n track_id = request.args.get('song')\n\n for song in raw_queue:\n if song['track_id'] == track_id[14:]:\n return json.dumps({'error': 'Cannot add a song already in the queue'})\n\n num_... | [
"0.72021145",
"0.7178171",
"0.68124354",
"0.67616093",
"0.6730884",
"0.661579",
"0.6544573",
"0.6535995",
"0.65308034",
"0.6529165",
"0.6515031",
"0.64952904",
"0.64827377",
"0.6465418",
"0.6454924",
"0.64515936",
"0.6450223",
"0.64397067",
"0.64342123",
"0.63851374",
"0.6346... | 0.8322641 | 0 |
Remove song from database and from the storage directory based on ID | def delete_song(self):
song_id = tuple(input("Give the melody id to be deleted:\t"))
sql = "SELECT file_title, form FROM songs WHERE id = %s" # Check existence of song with given ID
self.cursor.execute(sql, song_id)
result = self.cursor.fetchall()
if len(result) > 0:
path = self.p_storage + "/" + result[0][0] + "." + result[0][
1] # Find path of song by appending the name and format to the storage directory path
os.remove(path) # Remove song from directory
sql = "DELETE FROM songs WHERE id = %s" # Delete song from database
self.cursor.execute(sql, song_id)
self.cnx.commit()
print(self.cursor.rowcount, "record(s) deleted")
else:
print("Give a valid id...") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_song(_id):\r\n Song.query.filter_by(id=_id).delete()\r\n # filter song by id and delete\r\n db.session.commit() # commiting the new change to our database\r",
"def delete_music():\n track_id = request.vars.track_id\n if track_id is None:\n raise HTTP(500)\n db(db.... | [
"0.724472",
"0.68608385",
"0.68424237",
"0.6805456",
"0.66874766",
"0.6629392",
"0.65805244",
"0.65743804",
"0.6480073",
"0.6455035",
"0.64183515",
"0.6390148",
"0.63755953",
"0.6350693",
"0.63068855",
"0.6271331",
"0.62588185",
"0.6248313",
"0.62059045",
"0.6190672",
"0.6164... | 0.76542425 | 0 |
Modifies song info in the database | def modify_data(self):
song_id = tuple(input("Give the id of the song to be modified:\t")) # Request song ID
sql = "SELECT song_title, artist, data, tag FROM songs WHERE id = %s" # Find song with given ID
self.cursor.execute(sql, song_id)
res = self.cursor.fetchall()
if len(res) > 0:
while True:
sql = "SELECT song_title, artist, data, tag FROM songs WHERE id = %s" # Save current info
self.cursor.execute(sql, song_id)
result = self.cursor.fetchall()
modify = input(
"What do you want to modify? [title/artist/(release )date/tags/none]\t") # Request data to be
# modified
if modify == 'title': # Modify title
print('Current title is ' + result[0][0])
new = (input('Give new title:\t'), song_id[0])
sql = "UPDATE songs SET song_title = %s WHERE id = %s"
self.cursor.execute(sql, new)
self.cnx.commit()
print("New title assigned")
if modify == 'artist': # Modify artist
print('Current artist is ' + result[0][1])
new = (input('Give new artist:\t'), song_id[0])
sql = "UPDATE songs SET artist = %s WHERE id = %s"
self.cursor.execute(sql, new)
self.cnx.commit()
print("New artist assigned")
if modify == 'date': # Modify release date
print('Current date is ' + result[0][2])
new = (input('Give new date:\t'), song_id[0])
sql = "UPDATE songs SET data = %s WHERE id = %s"
self.cursor.execute(sql, new)
self.cnx.commit()
print("New date assigned")
if modify == 'tags': # Modify tags
print('Current tags are ' + result[0][3])
new = (input('Give new tags:\t'), song_id[0])
sql = "UPDATE songs SET tag = %s WHERE id = %s"
self.cursor.execute(sql, new)
self.cnx.commit()
print("New tags assigned")
if modify == 'none': # Do not modify anything, print the current song info
sql = "SELECT song_title, artist, data, tag FROM songs WHERE id = %s"
self.cursor.execute(sql, song_id)
result = self.cursor.fetchall()
print(
"Current data for the song with id" + song_id[0] + "are:\ntitle:" + result[0][0] + "\nartist:" +
result[0][1] + "\nrelease date:" + result[0][2] + "\ntags:" + result[0][3])
break
else:
print("Give a valid id...") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_db(self):\n songs = self.db.get_all_songs()\n for song in songs:\n if choose_song(song) == ERROR:\n self.db.delete_song(song)\n files = []\n for song in glob.glob(\"songs\\*.wav\"):\n to_append = song.split('\\\\')[ONE][:-4]\n f... | [
"0.7413717",
"0.6995219",
"0.68380946",
"0.6823178",
"0.66802067",
"0.6608994",
"0.6446211",
"0.6343561",
"0.6318853",
"0.6218813",
"0.6192342",
"0.6175601",
"0.6141071",
"0.61293864",
"0.61132926",
"0.60554576",
"0.6035266",
"0.6034275",
"0.5926394",
"0.592424",
"0.591346",
... | 0.70110184 | 1 |
Create a Batch from an existing batch id. Notes | def from_batch_id(batch_id: int, *args, **kwargs):
b = Batch(*args, **kwargs)
assert isinstance(b._backend, _backend.ServiceBackend)
b._batch_handle = b._backend._batch_client.get_batch(batch_id)
return b | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_batch(self, batch_name, priority = 0, comments = '', notifications = []):\n\n url = self._base_url + urlConfig.URLS['Project'] + '/' + self._project_id + '/batch'\n batch = {\n \"batch_name\": batch_name,\n \"priority\": priority,\n \"comments\": comments,\... | [
"0.69767964",
"0.69643956",
"0.6652114",
"0.6631825",
"0.61280215",
"0.6110446",
"0.60883904",
"0.60016143",
"0.59871805",
"0.5886255",
"0.5873244",
"0.58249927",
"0.5809669",
"0.57384014",
"0.5699515",
"0.56257725",
"0.56246674",
"0.5616465",
"0.551616",
"0.53761625",
"0.537... | 0.7599396 | 0 |
Create a new input resource file object representing a single file. | def read_input(self, path: str) -> _resource.InputResourceFile:
irf = self._new_input_resource_file(path)
return irf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_file_object(inputfile=None):\n if type(inputfile) == str:\n return open(inputfile, 'r')\n return inputfile",
"def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n content_type: Optional[pulumi.Input[U... | [
"0.6874475",
"0.6812216",
"0.65446967",
"0.65262955",
"0.6509462",
"0.6438844",
"0.6272451",
"0.62469476",
"0.61195093",
"0.60929656",
"0.6091407",
"0.60815406",
"0.60800767",
"0.6025725",
"0.5954721",
"0.59426826",
"0.59278876",
"0.59035605",
"0.5878973",
"0.5866811",
"0.585... | 0.70438915 | 0 |
Create a new resource group representing a mapping of identifier to input resource files. | def read_input_group(self, **kwargs: str) -> _resource.ResourceGroup:
root = secret_alnum_string(5)
new_resources = {name: self._new_input_resource_file(file, root) for name, file in kwargs.items()}
rg = _resource.ResourceGroup(None, root, **new_resources)
self._resource_map.update({rg._uid: rg})
return rg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_resource_group(self):\n pass",
"def load(self):\n self.suite.load()\n self.resource_map = {}\n dirlist = os.listdir(self.resources)\n for resource_name in (name for name in dirlist\n if os.path.isfile(os.path.join(self.resources,name... | [
"0.58438635",
"0.5761084",
"0.55505747",
"0.5540623",
"0.5514604",
"0.55128634",
"0.5483182",
"0.54395956",
"0.5409617",
"0.5397805",
"0.5392991",
"0.53768927",
"0.5376017",
"0.5359928",
"0.5356735",
"0.5327738",
"0.52933335",
"0.52924156",
"0.5286034",
"0.52811337",
"0.52422... | 0.6814466 | 0 |
Write resource file or resource file group to an output destination. Examples | def write_output(self, resource: _resource.Resource, dest: str):
if not isinstance(resource, _resource.Resource):
raise BatchException(f"'write_output' only accepts Resource inputs. Found '{type(resource)}'.")
if (isinstance(resource, _resource.JobResourceFile)
and isinstance(resource._source, job.BashJob)
and resource not in resource._source._mentioned):
name = resource._source._resources_inverse[resource]
raise BatchException(f"undefined resource '{name}'\n"
f"Hint: resources must be defined within the "
f"job methods 'command' or 'declare_resource_group'")
if (isinstance(resource, _resource.PythonResult)
and isinstance(resource._source, job.PythonJob)
and resource not in resource._source._mentioned):
name = resource._source._resources_inverse[resource]
raise BatchException(f"undefined resource '{name}'\n"
f"Hint: resources must be bound as a result "
f"using the PythonJob 'call' method")
if isinstance(self._backend, _backend.LocalBackend):
dest_scheme = url_scheme(dest)
if dest_scheme == '':
dest = os.path.abspath(os.path.expanduser(dest))
resource._add_output_path(dest) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, output, resources, **kw):\n\n raise NotImplementedError()",
"def write_resources(self, resources):\n for filename, data in list(resources.get('outputs', {}).items()):\n # Determine where to write the file to\n dest = os.path.join(self.output_dir, filename)\n ... | [
"0.7189583",
"0.67922026",
"0.6485851",
"0.6471249",
"0.5966388",
"0.5966388",
"0.5919293",
"0.58600813",
"0.5827604",
"0.5729985",
"0.5707116",
"0.5665977",
"0.55832523",
"0.557501",
"0.55459183",
"0.54772556",
"0.5467842",
"0.5445758",
"0.54371053",
"0.54174685",
"0.5403804... | 0.68054146 | 1 |
Select all jobs in the batch whose name matches `pattern`. Examples | def select_jobs(self, pattern: str) -> List[job.Job]:
return [job for job in self._jobs if job.name is not None and re.match(pattern, job.name) is not None] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_jobs(jobs, keyword):\n for job in jobs:\n if keyword == \"all\":\n yield job\n elif job[\"name\"].find(keyword) != -1:\n yield job",
"def search_by_pattern(self, tl):\n print(\"Search by regex pattern\")\n pattern = input(\"Please enter search patte... | [
"0.6330027",
"0.57241905",
"0.5717007",
"0.5662955",
"0.5661944",
"0.5415436",
"0.5401124",
"0.53878415",
"0.5367021",
"0.5349991",
"0.53413725",
"0.53162223",
"0.5308199",
"0.5304073",
"0.5292824",
"0.5277535",
"0.5271562",
"0.52473783",
"0.52251303",
"0.5207287",
"0.5199997... | 0.7555124 | 0 |
Execute a batch. Examples | def run(self,
dry_run: bool = False,
verbose: bool = False,
delete_scratch_on_exit: bool = True,
**backend_kwargs: Any) -> Optional[_bc.Batch]:
seen = set()
ordered_jobs = []
def schedule_job(j):
if j in seen:
return
seen.add(j)
for p in j._dependencies:
schedule_job(p)
ordered_jobs.append(j)
for j in self._jobs:
schedule_job(j)
assert len(seen) == len(self._jobs)
job_index = {j: i for i, j in enumerate(ordered_jobs, start=1)}
for j in ordered_jobs:
i = job_index[j]
j._job_id = i
for d in j._dependencies:
if job_index[d] >= i:
raise BatchException("cycle detected in dependency graph")
self._jobs = ordered_jobs
run_result = self._backend._run(self, dry_run, verbose, delete_scratch_on_exit, **backend_kwargs) # pylint: disable=assignment-from-no-return
if self._DEPRECATED_fs is not None:
# best effort only because this is deprecated
async_to_blocking(self._DEPRECATED_fs.close())
self._DEPRECATED_fs = None
return run_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_batch(self, batch_x, batch_y):\n raise NotImplementedError()",
"def ExecuteBatch(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)",
"def execute(self):\n return self._batch.execute()",
"def BeginExecuteBatch(self, request, context):\n context.code(beta... | [
"0.7048897",
"0.6716209",
"0.66513216",
"0.6633743",
"0.65684175",
"0.6428148",
"0.6417398",
"0.6358319",
"0.63045424",
"0.6275959",
"0.6252536",
"0.62219197",
"0.6158494",
"0.61560374",
"0.61498094",
"0.61498094",
"0.60457814",
"0.60279816",
"0.6023647",
"0.6015122",
"0.6008... | 0.0 | -1 |
Initializes querysets for keyword and headlinekeyword | def __init__(self):
self.keyword_queryset = Keyword.objects.all()
self.headlinekeyword_queryset = Headlinekeyword.objects.all()
self.headline_queryset = Headline.objects.all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keyword_headlines(self):\r\n\t\td = {}\r\n\r\n\t\tfor q in self.keyword_queryset:\r\n\t\t\td[q.content] = self.headlinekeyword_queryset.filter(keywordid = q.id)\r\n\r\n\t\treturn d",
"def get_queryset(self):\r\n return Keyword.objects.all()",
"def setup_eager_loading(cls, queryset):\n que... | [
"0.62303746",
"0.62133765",
"0.5979311",
"0.59030783",
"0.5808249",
"0.5781533",
"0.5741475",
"0.57359666",
"0.5595646",
"0.55684435",
"0.5490495",
"0.54874605",
"0.54597276",
"0.5437996",
"0.5390633",
"0.5304389",
"0.5293679",
"0.5290758",
"0.5277677",
"0.5255377",
"0.524341... | 0.7972529 | 0 |
Returns a dictionary of the keywords and the list of corresponding headlines (ids only) | def keyword_headlines(self):
d = {}
for q in self.keyword_queryset:
d[q.content] = self.headlinekeyword_queryset.filter(keywordid = q.id)
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_keywords(self):\r\n\t\treturn list(self.keyword_headlines().keys())",
"def get_headlines_with_keyword(self, kw):\r\n\t\tkey_head = self.keyword_headlines()\r\n\r\n\t\theadlines = set()\r\n\r\n\t\tfor headlinekw in key_head[kw]:\r\n\t\t\tcontent = headlinekw.headlineid.content\r\n\t\t\theadlines.add(conte... | [
"0.763168",
"0.7235824",
"0.71703315",
"0.65968394",
"0.61900103",
"0.6189536",
"0.609543",
"0.60951686",
"0.60745686",
"0.6041486",
"0.6003403",
"0.5991974",
"0.5966871",
"0.5924465",
"0.5924083",
"0.5896881",
"0.5850133",
"0.58487964",
"0.58361",
"0.58255136",
"0.5808301",
... | 0.81225014 | 0 |
Returns a list of keywords | def get_keywords(self):
return list(self.keyword_headlines().keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keywords(self):\n return list(self._kw)",
"def keywords(self):\n return self._keywords",
"def keywords(self):\n return self._keywords",
"def getKeywords(self):\n return",
"def keywords(self):\n return self.__keywords",
"def extract_keywords(self):\n keywords ... | [
"0.82068",
"0.80030465",
"0.80030465",
"0.79815817",
"0.7965522",
"0.795927",
"0.79124683",
"0.7827855",
"0.7802334",
"0.7794272",
"0.77290803",
"0.7597001",
"0.7496878",
"0.74123514",
"0.7399484",
"0.73888963",
"0.737007",
"0.7306008",
"0.7305014",
"0.73011196",
"0.7273646",... | 0.8675625 | 0 |
Returns a list of lists [word, number of headlines] | def keyword_frequencies(self, limit = None):
key_head = self.keyword_headlines()
freq_list = []
for keyword in key_head:
numHeadlines = len(key_head[keyword])
if limit:
if numHeadlines > limit:
numHeadlines = limit
freq_list.append([keyword, numHeadlines])
return freq_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_headlines(self):\n headlines = re.findall(r\"^\\.\\.\\.(.*?)\\.\\.\\.[ ]?\\n\\n\", self.unixtext,\n re.M | re.S)\n headlines = [\" \".join(h.replace(\"...\",\n \", \").replace(\"\\n\", \" \").split())\n ... | [
"0.6359982",
"0.63080597",
"0.62195677",
"0.6214322",
"0.6143615",
"0.614284",
"0.6101072",
"0.60887766",
"0.5984331",
"0.5945753",
"0.58900934",
"0.5865218",
"0.5827097",
"0.5822467",
"0.5805729",
"0.5790344",
"0.575367",
"0.5737365",
"0.5706382",
"0.5671385",
"0.5618535",
... | 0.54709244 | 40 |
Returns a list of headlines if given a keyword | def get_headlines(self, kw = None):
if kw:
return self.get_headlines_with_keyword(kw)
else:
return self.get_all_headlines() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_headlines_with_keyword(self, kw):\r\n\t\tkey_head = self.keyword_headlines()\r\n\r\n\t\theadlines = set()\r\n\r\n\t\tfor headlinekw in key_head[kw]:\r\n\t\t\tcontent = headlinekw.headlineid.content\r\n\t\t\theadlines.add(content)\r\n\r\n\t\treturn list(headlines)",
"def keyword_headlines(self):\r\n\t\td ... | [
"0.8183849",
"0.7191412",
"0.7000567",
"0.66961074",
"0.66491723",
"0.66434336",
"0.6356157",
"0.6131674",
"0.61187565",
"0.59622735",
"0.59542644",
"0.5890983",
"0.5875384",
"0.57926047",
"0.57580566",
"0.5697247",
"0.56422436",
"0.5626344",
"0.55865705",
"0.5584343",
"0.556... | 0.8182654 | 1 |
Returns a list of all headlines | def get_all_headlines(self):
list_vals = list(self.keyword_headlines().values())
uniq_headlines = set()
for list_val in list_vals:
for headlineobj in list_val:
uniq_headlines.add(headlineobj.headlineid.content)
return list(uniq_headlines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_headlines(self, kw = None):\r\n\t\tif kw:\r\n\t\t\treturn self.get_headlines_with_keyword(kw)\r\n\t\telse:\r\n\t\t\treturn self.get_all_headlines()",
"def all_headlines(html_root_node):\n pass",
"def all_headlines_from(url):\n pass",
"def parse_headlines(self):\n headlines = re.findall(r... | [
"0.81433356",
"0.789887",
"0.76946384",
"0.7529572",
"0.7259968",
"0.7255244",
"0.70318645",
"0.70286566",
"0.6947499",
"0.6834149",
"0.6717767",
"0.6677363",
"0.6588224",
"0.6471544",
"0.6457992",
"0.64250094",
"0.64140487",
"0.64032876",
"0.63827264",
"0.635251",
"0.6352418... | 0.76380426 | 3 |
Returns a list of the headlines with the corresponding keyword | def get_headlines_with_keyword(self, kw):
key_head = self.keyword_headlines()
headlines = set()
for headlinekw in key_head[kw]:
content = headlinekw.headlineid.content
headlines.add(content)
return list(headlines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_headlines(self, kw = None):\r\n\t\tif kw:\r\n\t\t\treturn self.get_headlines_with_keyword(kw)\r\n\t\telse:\r\n\t\t\treturn self.get_all_headlines()",
"def keyword_headlines(self):\r\n\t\td = {}\r\n\r\n\t\tfor q in self.keyword_queryset:\r\n\t\t\td[q.content] = self.headlinekeyword_queryset.filter(keyword... | [
"0.8323906",
"0.77197367",
"0.746953",
"0.7303126",
"0.68182117",
"0.6805935",
"0.66141784",
"0.64018786",
"0.6364445",
"0.63333815",
"0.59744793",
"0.59658384",
"0.59578186",
"0.5909768",
"0.5894226",
"0.58745706",
"0.5857797",
"0.5850383",
"0.58470386",
"0.58389264",
"0.581... | 0.8318916 | 1 |
Welcome route Show api info | def get(self, **kwargs):
# groups = kwargs.get('groups')
return {
'app_fullname': main_config.app_name,
'app_name': main_config.package_name,
'app_version': main_config.app_version
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def welcome():\n return(\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/etf_info<br/>\"\n f\"/api/v1.0/mutualfunds_info\"\n )",
"def welcome():\n print(\"Server received request for 'Home' page...\")\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/names<br/>\"... | [
"0.78570443",
"0.7700679",
"0.76447624",
"0.76302814",
"0.76104695",
"0.75441355",
"0.7513181",
"0.75017893",
"0.748835",
"0.748835",
"0.747807",
"0.7470789",
"0.7469684",
"0.7465586",
"0.7445721",
"0.74422014",
"0.7441175",
"0.7425304",
"0.74079293",
"0.7407577",
"0.74064386... | 0.0 | -1 |
prettyprint a table. Every column's width is the width of the widest field in that column. The given table should be a list of lists. That is, it should be a list of rows, where every row is a list of fields. To get the width of each column, we'll transpose the table. For efficiency, if the caller already has a transposed version of the table, they can pass that into us so we don't have to retranspose it. Both the table, and the transposed version of the table, will be traversed exactly once, so it's fine if they are just generator functions. | def texttable(table, left=False):
widths = (max(len(fld) for fld in line)
for line in itertools.izip_longest(*table, fillvalue=""))
lc = '-' if left else ''
formats = ["%{0}{1}s".format(lc, width) for width in widths]
return ORS.join("%s" % OFS.join(format % fld
for (format, fld) in zip(formats, line))
for line in table) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_table(table):\n # transpose the table:\n table = map(list, zip(*table))\n # get the column width:\n col_width = [max(len(str(x)) for x in col) for col in zip(*table)]\n # print it to screen:\n print\n for line in table:\n print \"| \" + \" | \".join(\"{:{}}\".format(x, col_wid... | [
"0.7072573",
"0.70656246",
"0.68265593",
"0.6811348",
"0.67818946",
"0.6566554",
"0.6547522",
"0.6480734",
"0.64619523",
"0.6371777",
"0.6231521",
"0.61801976",
"0.6153712",
"0.61120504",
"0.60410714",
"0.60410714",
"0.6018116",
"0.6011745",
"0.6011745",
"0.6009689",
"0.59695... | 0.5369287 | 63 |
Get the nbest logits from a list. | def _get_best_indexes(logits, n_best_size):
index_and_score = sorted(enumerate(logits), key=lambda x: x[1], reverse=True)
best_indexes = []
for i in range(len(index_and_score)):
if i >= n_best_size:
break
best_indexes.append(index_and_score[i][0])
return best_indexes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_best_indexes(logits, n_best_size):\n index_and_score = sorted(enumerate(logits), key=lambda x: x[1], reverse=True)\n\n best_indexes = []\n for i in range(len(index_and_score)):\n if i >= n_best_size:\n break\n best_indexes.append(index_and_score[i][0])\n return best_indexes",
"def _get_be... | [
"0.6809752",
"0.67892396",
"0.677396",
"0.6740539",
"0.6667522",
"0.623828",
"0.585659",
"0.5845603",
"0.5799747",
"0.5723129",
"0.56909186",
"0.565728",
"0.5616109",
"0.5616109",
"0.56132007",
"0.56086874",
"0.55966324",
"0.5583005",
"0.5578795",
"0.55542535",
"0.5510991",
... | 0.67765886 | 4 |
Make sure that when we remove an option, only ~1/10th of the keys get moved. | def test_rendezvous_hash_roughly_fractional_change():
first_choices = range(10)
second_choices = range(9)
test_keys = [str(x) for x in range(10000)]
first_results = [
marathon_tools.rendezvous_hash(first_choices, k) for k in test_keys
]
second_results = [
marathon_tools.rendezvous_hash(second_choices, k) for k in test_keys
]
num_same = len([1 for x, y in zip(first_results, second_results) if x == y])
assert num_same > 8900
assert num_same < 9100 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def truncateto(self, commandnumber):\n keytuples = self.pvalues.keys()\n allkeys = sorted(keytuples, key=lambda keytuple: keytuple[0])\n # Sanity checking\n lastkey = allkeys[0][0]\n candelete = True\n for (cmdno,proposal) in allkeys:\n if cmdno == lastkey:\n ... | [
"0.6069215",
"0.60325634",
"0.59787893",
"0.5949097",
"0.58923924",
"0.573072",
"0.56973803",
"0.56719327",
"0.5616844",
"0.5563222",
"0.55309904",
"0.55171895",
"0.5499191",
"0.54319483",
"0.5431215",
"0.5413914",
"0.5403386",
"0.53861636",
"0.53794116",
"0.53793514",
"0.536... | 0.0 | -1 |
Calculate the min number of refills to reach 'distance'. You start with a full tank. | def compute_min_refills(distance: int, tank: int, stops: List[int]):
location: int = 0
n_stops = 0
last_stop = 0
max_drive = location + tank
while max_drive < distance:
counter = 0
# Handle the case that stops are depleted before we reach distance
if len(stops) == 0:
return -1
for s in stops:
if s <= max_drive:
counter += 1
last_stop = s
max_drive = last_stop + tank
# Handle the case that wi did not reach the next stop
if counter == 0:
return -1
else:
del stops[0:counter]
n_stops += 1
return n_stops | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_min_refills(distance, tank, stops):\n\n num_refills = 0\n current_refill = 0\n\n all_stops = []\n all_stops.append(0)\n for stop in stops:\n \tall_stops.append(stop)\n all_stops.append(distance)\n\n num_stops = len(all_stops)\n\n while current_refill < num_stops:\n \tlast_... | [
"0.8302289",
"0.6621628",
"0.645036",
"0.6314632",
"0.6262712",
"0.61484736",
"0.60885",
"0.603681",
"0.59223753",
"0.58915836",
"0.5876038",
"0.5869804",
"0.58609515",
"0.58593315",
"0.58491707",
"0.5815681",
"0.5806749",
"0.57953686",
"0.57733434",
"0.5757533",
"0.57270324"... | 0.7821262 | 1 |
Given the positions of a list of the indices, create a unique key to register the position. | def placementKey( geo):
def diagcmp( xyA, xyB):
"""
Compare two positions based on x + y. If x + y is the same for the
two, compare based on x.
"""
return cmp(xyA[0] + xyA[1], xyB[0] + xyB[1]) or cmp(xyA[0], xyB[0])
sorted = [ tuple(geo[i]) for i in xrange(geo.shape[0]) ]
sorted.sort( diagcmp)
return hash(tuple(sorted)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_new_key(idx, key, d):\n\n new_key = \"%s_%d\" % (key, idx)\n if new_key in d:\n return make_new_key(idx + 1, key, d)\n return new_key",
"def _make_key(self):\n all_position_values = (chromosome_sort_key(self.chromosome), self.min_position, self.max_position, \n ... | [
"0.6364943",
"0.59690577",
"0.58550936",
"0.58094066",
"0.5801118",
"0.5798134",
"0.5770239",
"0.57411945",
"0.57236964",
"0.5721956",
"0.56699497",
"0.56316316",
"0.5616401",
"0.5541196",
"0.55281365",
"0.5510795",
"0.5509949",
"0.54963547",
"0.5487912",
"0.5483186",
"0.5469... | 0.53552693 | 35 |
Compare two positions based on x + y. If x + y is the same for the two, compare based on x. | def diagcmp( xyA, xyB):
return cmp(xyA[0] + xyA[1], xyB[0] + xyB[1]) or cmp(xyA[0], xyB[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmp(x, y):\n if x + y > y + x: return 1\n elif x + y == y + x: return 0\n else: return -1",
"def same(self, x: int, y: int):\n\n return self.find(x) == self.find(y)",
"def position_equal(self, a, b):\n return None",
"def cmp_position(self, other):\n if se... | [
"0.723032",
"0.7027254",
"0.69411623",
"0.6835873",
"0.6783057",
"0.6730236",
"0.67250097",
"0.6706741",
"0.66703665",
"0.65392756",
"0.65288377",
"0.65262926",
"0.652476",
"0.6507796",
"0.6501238",
"0.64775836",
"0.6462285",
"0.6461377",
"0.64430475",
"0.6422668",
"0.637349"... | 0.6058523 | 49 |
For the given geometry, construct the symmetry and nondegenerate operations associated with the piece. | def __init__( self, geo, index=None):
# the column vector self.geo[:,i] gives the i'th vertex's positions
self.geo = np.array( geo, dtype=int)
self.findNondegeneratePlacements()
self.id = index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sym_elements(self):\n def trans(name, *sym):\n t = Element.TRANSFORMS\n n = name.split('_')\n\n for x in sym:\n n[-1] = t[x][n[-1]]\n\n return '_'.join(n)\n\n def primary():\n e = self.copy()\n e.name = '{}_p'.format... | [
"0.5479113",
"0.5462708",
"0.54347366",
"0.53193223",
"0.53082114",
"0.51953447",
"0.5145413",
"0.51347935",
"0.508981",
"0.5083603",
"0.50094604",
"0.5006806",
"0.49864545",
"0.49627787",
"0.4931252",
"0.49236828",
"0.4907775",
"0.49058902",
"0.4894753",
"0.48798862",
"0.487... | 0.0 | -1 |
Place the vertex v at position, and apply transformation T. Return the grid points that are occupied by the piece. | def place( self, position, v, T):
geo = (self.geo - self.geo[v]).dot( T)
return position + geo | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def translate(self, v):\n return Position.fromnp(translate(self.tonp(), v))",
"def project_vector(u, v):\n u_np = np.array([u.get_x(), u.get_y()])\n v_np = np.array([v.get_x(), v.get_y()])\n proj = (np.dot(u_np, v_np) / np.dot(v_np, v_np)) * v_np\n return Point(proj[0], proj[1])",
"def trans... | [
"0.61589414",
"0.5887289",
"0.56152284",
"0.55743974",
"0.5553705",
"0.55252033",
"0.55161303",
"0.54971194",
"0.5430372",
"0.54015726",
"0.5349081",
"0.5345369",
"0.53373307",
"0.53254366",
"0.5311833",
"0.5305778",
"0.5302551",
"0.53003585",
"0.52812153",
"0.52796966",
"0.5... | 0.65050745 | 0 |
Generate all nondegenerate placements, with one of the vertices placed at (0,0). Return the placements as [ (v, T) ], where v is the vertex to be placed at (0,0), and T the 2x2 transformation matrix that place the piece according to self.geo[v] + T.dot(self.geo self.geo[v]) | def findNondegeneratePlacements( self):
# Rotate counterclockwise by 90 degrees around the v'th vertex.
r90 = np.array( [ [0,1], [-1,0] ], dtype=int)
# Flip the piece along the vertical axis through the v'th vertex.
fv = np.array( [ [1,0], [0,-1] ], dtype=int)
self.placements = []
uniques = set() # Unique placements generated so far
identity = np.array( [ [1,0], [0,1] ], dtype=int)
T = identity[:,:]
for i in xrange(self.nVertices):
geo = self.geo[:,:]
geo -= geo[i] # Place i'th vertex at (0,0)
for r in xrange(4):
T = T.dot( r90)
for f in xrange(2):
T = T.dot( fv)
pk = placementKey( geo.dot(T))
if (not pk in uniques):
uniques.add( pk)
self.placements.append( (i, T))
# After four rotations and two flips, we should be back to
# the original position.
assert( np.array_equal( T, identity))
return self.placements | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_all_locations(grid, shape):",
"def test_create_new_placements(self):\n subv = SimpleMachineVertex(None, \"\")\n pl = Placement(subv, 0, 0, 1)\n Placements([pl])",
"def generate_nearby_cells(self):\n for y in range(len(self.island_map)):\n for x in range(len(s... | [
"0.6300398",
"0.59959567",
"0.5966825",
"0.5925378",
"0.58771193",
"0.5777176",
"0.57712615",
"0.57712615",
"0.5769345",
"0.5725288",
"0.5673758",
"0.5602161",
"0.56021327",
"0.56002945",
"0.5596927",
"0.5585428",
"0.5523877",
"0.5508298",
"0.5461161",
"0.546076",
"0.5455531"... | 0.7902054 | 0 |
Construct a Lonpos state, with the given board and pieces. The occupation array indicates which points of the board are occupied, and by what pieces. It is specified by [ (p, i) ], which indicate point p of the board is occupied by i'th piece. p can be either the index or the 2d coordinates of the point. | def __init__( self, board, occupation=[]):
self.board = board
if (occupation):
if (isinstance(occupation[0][0], int)):
self.occupation = dict(occupation)
elif (isinstance(occupation[0][0], tuple) and len(occupation[0][0])==2):
try:
self.occupation = dict(
[ (board.grids[o[0]], o[1]) for o in occupation ])
except KeyError, e:
raise e, "Occupied point not on board."
else:
self.occupation = dict(occupation) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, params):\n position = recordtype(\"position\", [\"x\", \"y\", \"kind\"])\n coordinate = recordtype(\"coordinate\", [\"x\", \"y\"])\n\n self.width = params[\"m\"]\n self.height = params[\"n\"]\n self.count = 0\n self.pieces = params[\"pieces\"]\n\n ... | [
"0.6446085",
"0.63221157",
"0.6167907",
"0.6051009",
"0.6044088",
"0.6041356",
"0.5958236",
"0.5945604",
"0.5903196",
"0.589366",
"0.5844264",
"0.5821776",
"0.5812927",
"0.5807781",
"0.57963544",
"0.5786014",
"0.5778081",
"0.5771436",
"0.5771375",
"0.5727038",
"0.56882375",
... | 0.6202576 | 2 |
Use ASCII to illustrate the state of the Lonpos. | def show( self):
def symbol( i):
return i<0 and (i==-2 and ' ' or '0') or chr(ord('a') + i)
X, Y = np.max( self.board.positions, 0)
# -2 to indicate outside board.
display = np.zeros( (X+1,Y+1), dtype=int) - 2
for x, y in self.board.positions:
display[x, y] = -1 # -1 to indicate unoccupied
for p, i in self.occupation.items():
x, y = self.board.positions[p]
display[x, y] = i
for x in xrange(X+1):
s = ''.join( [ symbol( display[x, y]) for y in xrange(Y+1) ])
print s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n s = \" position:\" + str(self.pos) + \"\\n\"\n s += \" heading: \" + str(self.heading) + \"\\n\"\n return s",
"def __str__(self):\n tapeline = self.tape.format(\n self.index - 10, self.index + 11) + ' : state {}'.format(self.state)\n pointline... | [
"0.6132644",
"0.612283",
"0.60547996",
"0.60443765",
"0.5874516",
"0.5855971",
"0.5843751",
"0.5838602",
"0.5808942",
"0.58021694",
"0.57527065",
"0.57486653",
"0.57406795",
"0.5740448",
"0.570328",
"0.56801385",
"0.56685424",
"0.5661247",
"0.56583273",
"0.5644304",
"0.564411... | 0.5684829 | 15 |
Count unoccupied neighbors of a point. | def countFreeNeighbors( p, board, occupation):
n = 0
for m in [0, 1]:
for d in [-1, 1]:
pn = [p[0], p[1]]
pn[m] += d
j = board.grids.get( tuple(pn), None)
if (j is None): continue # Not a board point
if (occupation.has_key( j)): continue # Occupied
n += 1
return n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_neighboors(self, x: int, y: int) -> int :\n\n cpt : int = 0\n min_x : int = max(0, x - 1)\n max_x : int = min(x + 1, self.width-1)\n min_y : int = max(0, y - 1)\n max_y : int = min(y + 1, self.height-1)\n\n x_tmp : int\n y_tmp : int\n for x_tmp in r... | [
"0.7307373",
"0.7237684",
"0.7203775",
"0.71407646",
"0.6955501",
"0.68983823",
"0.6883159",
"0.6826486",
"0.6824896",
"0.6804748",
"0.6788591",
"0.67754936",
"0.67619663",
"0.67619663",
"0.67333233",
"0.6709194",
"0.66639596",
"0.66181695",
"0.657233",
"0.65499747",
"0.65250... | 0.7302581 | 1 |
Find unoccupied positions on the board. | def findUnoccupied( board, occupation):
return [ j for j in xrange(len(board.positions))
if not occupation.has_key(j) ] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def free_positions(self):\n positions = []\n for i in range(self.grid_size):\n for j in range(self.grid_size):\n if self.grid[i][j] == 0:\n positions.append((i, j))\n if positions == []:\n raise GameException('Game Over. No free position ... | [
"0.74757147",
"0.73623365",
"0.7305674",
"0.72659814",
"0.7136726",
"0.6983209",
"0.6902076",
"0.69016534",
"0.68626094",
"0.6858928",
"0.67981094",
"0.67022055",
"0.66423976",
"0.65927297",
"0.6580229",
"0.6564762",
"0.65628403",
"0.6559673",
"0.654521",
"0.65293694",
"0.652... | 0.77521825 | 0 |
Use a depthfirstsearch to solve the Lonpos puzzle. | def solve( board, pieces, occupation):
from heapq import heappush, heappop
unoccupied = findUnoccupied( board, occupation)
remainingpieces = range(len(pieces))
searchq = []
nbacktrack = 0
while (unoccupied):
nnheap = []
# As a heuristic, we choose to first place pieces on points
# with the least number of unoccupied neighbors.
for i in unoccupied:
p = board.positions[i]
nn = countFreeNeighbors( p, board, occupation)
heappush( nnheap, (nn, i))
nn, pt = heappop( nnheap)
if (nn==0): # No solution, back-track
if (searchq):
occupation, remainingpieces = searchq.pop()
nbacktrack += 1
print "Backtracking for the %d'th time" % nbacktrack
unoccupied = findUnoccupied( board, occupation)
continue
else:
break
for ipc in remainingpieces:
pc = pieces[ipc]
for o in placePiece( board, occupation, board.positions[pt], pc):
# A search node is defined by the occupation state and
# the remaining pieces.
searchq.append( (o, [i for i in remainingpieces if i != ipc]))
if (searchq):
occupation, remainingpieces = searchq.pop()
unoccupied = findUnoccupied( board, occupation)
else:
break
else:
state = LonposState( board, occupation.items())
state.show()
return occupation
# No solution for the state.
print "No solution!"
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()",
"def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n \n util.raiseNotDefined()",
"def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n #Creamos las estructuras de datos necesarias (stack y... | [
"0.70110327",
"0.6945343",
"0.67388815",
"0.6720618",
"0.6668133",
"0.66212654",
"0.65762824",
"0.65408486",
"0.65394676",
"0.65213966",
"0.65150017",
"0.6503912",
"0.64855695",
"0.64802074",
"0.64769286",
"0.6470355",
"0.64611316",
"0.6455134",
"0.64195275",
"0.6398742",
"0.... | 0.6093073 | 37 |
Returns a QuerySet containing only available instances (i.e. not selected previously) | def available(self, include_qs = None, include_obj = None):
qs = self.all()
available_qs = self.all()
for obj in qs:
if include_qs:
if not obj.available and include_qs.filter(id=obj.id).count() == 0:
available_qs = available_qs.exclude(id=obj.id)
elif include_obj:
if not obj.available and obj.id != include_obj.id:
available_qs = available_qs.exclude(id=obj.id)
else:
if not obj.available:
available_qs = available_qs.exclude(id=obj.id)
return available_qs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queryset(self):\n return NoneToEmptyQuerySet(self.model, using=self._db)",
"def get_queryset(self):\n # the filter says that it only returns those w/ the pub_date\n # less or equal to timezone.now() (earlier or now)\n questions = Question.objects.filter(\n pub_date_... | [
"0.6884471",
"0.68695015",
"0.67739236",
"0.67603797",
"0.671835",
"0.65459937",
"0.6483099",
"0.64685464",
"0.64685464",
"0.6414166",
"0.6411734",
"0.6331146",
"0.6330862",
"0.6273209",
"0.6255611",
"0.6248718",
"0.62450546",
"0.6231552",
"0.6221019",
"0.6218501",
"0.6209835... | 0.6682215 | 5 |
Determines whether the model instance has already been selected in a related field (ManyToManyField, OneToOneField). | def available(self):
fields = self._meta.get_fields()
for field in fields:
if isinstance(field, models.ManyToManyRel):
attr = field.get_accessor_name()
if getattr(self, attr).count() > 0:
return False
elif isinstance(field, models.OneToOneRel):
attr = field.get_accessor_name()
if getattr(self, attr, None):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relation_exists(cls, model):\n return bool(cls.get_related_field(model)\n or cls.get_reverse_related_field(model))",
"def isRelated(self):\n return len(self.user_storage.all()) > 0",
"def has_field(self, field):\n return field in self.extra_fields",
"def contains(s... | [
"0.6742698",
"0.6351571",
"0.6249839",
"0.6177484",
"0.594861",
"0.58511186",
"0.58348316",
"0.5823608",
"0.5715787",
"0.56835854",
"0.5671056",
"0.5618836",
"0.5598657",
"0.5598657",
"0.55803764",
"0.55689776",
"0.5560058",
"0.55562407",
"0.551438",
"0.55038196",
"0.54985",
... | 0.66686696 | 1 |
outputs the A vector | def getA(self):
return self.theta | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def A(self):\n return self._representation_vector[1:]",
"def return_vec(self) :\r\n y_vec = np.concatenate((self.x_vec,self.v_vec))\r\n return y_vec",
"def print_vector(self):\n print self.x, self.y, self.z",
"def v(self) -> np.ndarray:\n return self.A[1:] if self.scalar_ve... | [
"0.6733412",
"0.673054",
"0.6519931",
"0.64849705",
"0.64376384",
"0.6289511",
"0.62315416",
"0.62300235",
"0.62070984",
"0.61930376",
"0.61860853",
"0.61663204",
"0.61269957",
"0.609983",
"0.6096781",
"0.60403943",
"0.60208887",
"0.5975669",
"0.5926071",
"0.5925174",
"0.5898... | 0.0 | -1 |
outputs the noise or bias | def getB(self):
return self.error | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def noise(self, stddev):\n #add noise to weights\n pass",
"def noise(self, freq: int, /) -> None:",
"def add_noise(self, data):",
"def noisePreset() :\n s.noisePreset()",
"def noiseReduction(self):\n pass",
"def white_noise():\n return random.randint(-32767, 32767)",
"def noi... | [
"0.72268444",
"0.6808519",
"0.67288476",
"0.6671144",
"0.6670958",
"0.6571604",
"0.6559497",
"0.65078646",
"0.6505491",
"0.64908093",
"0.6452366",
"0.63892174",
"0.6370349",
"0.6341129",
"0.63222975",
"0.6292225",
"0.62755954",
"0.6267123",
"0.6263561",
"0.6238834",
"0.620964... | 0.0 | -1 |
outputs the covariance matrix | def getCovarianceMatrix(self):
#ypost = np.dot ( self.getA().T, self.priorX )
theta = np.mat ( self.getA() )
Xm = np.mat ( self.priorX )
ypost = Xm * theta
yprior = self.priorY
error = ypost - yprior
#error = error - np.mean ( error, axis = 0 )
return np.dot ( error.T, error ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compute_covariance_matrix(\n self.list_observations, self.list_observations)\n\n self.cov_matrix += np.diag(np.array([self.noise] * self.n_observation))\n\n return self.cov_matrix",
"def c... | [
"0.7898988",
"0.7637602",
"0.7582342",
"0.74682164",
"0.73953617",
"0.7171067",
"0.71467644",
"0.6950389",
"0.6944435",
"0.6932731",
"0.6891629",
"0.68414915",
"0.68384755",
"0.68313056",
"0.68222475",
"0.67440724",
"0.6723901",
"0.67163885",
"0.6713542",
"0.6699285",
"0.6695... | 0.7279606 | 5 |
outputs the noise covariance matrix, R | def getCovarianceNoiseMatrix(self):
return np.dot ( self.getB().T, self.getB() ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compute_covariance_matrix(\n self.list_observations, self.list_observations)\n\n self.cov_matrix += np.diag(np.array([self.noise] * self.n_observation))\n\n return self.cov_matrix",
"def c... | [
"0.71300656",
"0.66976005",
"0.6629202",
"0.6629202",
"0.6629202",
"0.6622315",
"0.6622108",
"0.6622073",
"0.6570352",
"0.6554128",
"0.6520113",
"0.64823085",
"0.64064324",
"0.6393191",
"0.6317923",
"0.62303",
"0.6217225",
"0.6212507",
"0.6195888",
"0.6166094",
"0.612643",
... | 0.7025741 | 1 |
This will check whether the entires are pairwise close enough (within tol) | def CompareMatrices(mat1, mat2, tol):
# just going to assume they are the same size...
for i in range(len(mat1)):
for j in range(len(mat1)):
if abs(mat1[i][j] - mat2[i][j]) > tol:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_symmetric(adj : np.ndarray, tol : float = 1e-8) -> bool:\n return np.all(np.abs(adj-adj.T) < tol)",
"def check_restraint_pairs_for_doubles(list): # Also consider that a1 and a2 can be switches\r\n for i in range(len(list) - 1):\r\n for j in range(i + 1, len(list)):\r\n if (list... | [
"0.6715366",
"0.65444267",
"0.65051025",
"0.64619166",
"0.63805026",
"0.6331604",
"0.6313639",
"0.6308023",
"0.62470406",
"0.61799294",
"0.61504745",
"0.6149808",
"0.6135852",
"0.6134906",
"0.61283964",
"0.6122861",
"0.6102767",
"0.6097179",
"0.60936743",
"0.60933644",
"0.608... | 0.0 | -1 |
Takes a list of tuples, and each element is compared to the next one Any tuple that changes has the index of it returned | def ContinuousCompare(lst, tol):
changing_indices = set()
last_tup = None
# iterate over all the tuples
for i in range(len(lst)):
# if it's the first entry, we just want to assign it and move onto the
# next iteration
if i == 0:
last_tup = lst[i]
continue
else:
tup = lst[i]
# remove the indices already found to change so we don't keep testing
# them
indices_left_to_check = set(range(len(tup))) - changing_indices
for j in indices_left_to_check:
if (tup[j] - last_tup[j]).magnitude > tol:
# if it changes, add it to the list
changing_indices.add(j)
last_tup = tup
return changing_indices | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task9_find_before_tuple(lst):\n result = 0\n for elem in lst:\n if isinstance(elem, tuple):\n result = lst[lst.index(elem) - 1]\n break\n return result",
"def innerloop(the_list):\n for index in range(len(the_list)-1):\n if the_list[index] > the_list[index+1]:\... | [
"0.69720376",
"0.67319834",
"0.6196822",
"0.6108386",
"0.60973054",
"0.5961634",
"0.58837163",
"0.58421284",
"0.57686746",
"0.5747028",
"0.5688401",
"0.56793284",
"0.5658989",
"0.56409854",
"0.56406134",
"0.56301296",
"0.56054074",
"0.5603956",
"0.5601578",
"0.55650455",
"0.5... | 0.629942 | 2 |
Determine if the object has a parent with the supplied name. | def has_parent(obj, parent_name):
if obj.parent is None:
return False
if obj.parent.name is None:
return False
elif obj.parent.name == parent_name:
return True
else:
return has_parent(obj.parent, parent_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_parent(self):\n return self.parent != None",
"def has_parent(self):\n return self._parent_ is not None",
"def _contains_in_self_or_parent(self, name: str) -> bool:\n return name in self",
"def is_parent(self):\n if self.parent is not None:\n return False\n ... | [
"0.7545343",
"0.7435591",
"0.73406065",
"0.7337848",
"0.7336612",
"0.7255639",
"0.7117234",
"0.7116028",
"0.70370907",
"0.6815638",
"0.6784905",
"0.67783093",
"0.6720416",
"0.6667514",
"0.6614133",
"0.6522801",
"0.6410729",
"0.640435",
"0.63520426",
"0.6320416",
"0.6236038",
... | 0.8476002 | 0 |
The event triggered when an error is raised while invoking a command. | async def on_command_error(self, ctx, error):
if hasattr(ctx.command, 'on_error'):
return
ignored = (commands.CommandNotFound, commands.UserInputError)
error = getattr(error, 'original', error)
try:
if isinstance(error, ignored):
return
elif isinstance(error, commands.DisabledCommand):
return await send(ctx,
self.messages.disabled.format(ctx.command),
tag=True, expire=True)
elif isinstance(error, commands.CheckFailure):
return await send(ctx,
self.messages.no_pm.format(ctx.command),
tag=False, expire=True)
elif isinstance(error, ArgIsNaN):
return await send(ctx,
self.messages.arg_is_nan.format(
error.args[0]
), tag=True, expire=True)
elif isinstance(error, PageOOB):
return await send(ctx,
self.messages.page_oob,
tag=True, expire=True)
elif isinstance(error, WrongArgLength):
return await send(ctx,
self.messages.wrong_arg_length.format(
ctx.command, error.args[0]
), tag=True, expire=True)
elif isinstance(error, UserNotFound):
return await send(ctx,
self.messages.user_not_found.format(
error.args[0]
), tag=True, expire=True)
elif isinstance(error, CommandError):
return await send(ctx,
self.messages[error.command][error.args[0]],
tag=True, expire=True)
except Exception:
pass
exception_string = ctx.author.mention + "\n```" + \
"".join(traceback.format_exception(
type(error), error, error.__traceback__
)) + "```"
if ctx.guild == None:
await ctx.send(
content=exception_string
)
return
channel = None
for possible_channel in ctx.guild.channels:
if possible_channel.name == self.messages.error_channel:
channel = possible_channel
break
if channel:
await channel.send(exception_string) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def on_command_error(self, ctx, error):\n\n if hasattr(ctx.command, 'on_error'):\n return\n\n error = getattr(error, 'original', error)\n\n if isinstance(error, commands.MissingRequiredArgument):\n LOG.error(f\"Missing argument in command {ctx.command}\")\n ... | [
"0.7980478",
"0.7709615",
"0.76937354",
"0.7669524",
"0.7622439",
"0.7463245",
"0.7443354",
"0.7433384",
"0.7432164",
"0.7427173",
"0.74214035",
"0.74195987",
"0.72977245",
"0.72538507",
"0.7153273",
"0.714725",
"0.6872951",
"0.681055",
"0.68062097",
"0.6620473",
"0.66178834"... | 0.72716826 | 13 |
will simulation PARALLEL_UNIVERSES_COUNT universes then, will return the overall multiverse survival of the player | def compute_player_score():
progress_bar = ProgressBar(label="Computing universes")
survivals_count = 0
for i in range(PARALLEL_UNIVERSES_COUNT):
if simulate_universe():
survivals_count += 1
progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)
progress_bar.end("\n\n")
return survivals_count / PARALLEL_UNIVERSES_COUNT | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_god_score():\n\n survivals_count = 0\n for _ in range(PARALLEL_UNIVERSES_COUNT):\n best_survival = random.uniform(MIN_DISEASE_SURVIVAL, MAX_DISEASE_SURVIVAL)\n for _ in range(random.randint(MIN_TREATMENTS_COUNT, MAX_TREATMENTS_COUNT)):\n treated_survival = random.uniform(... | [
"0.66658336",
"0.5772919",
"0.57570714",
"0.5285743",
"0.52517307",
"0.51297843",
"0.5128983",
"0.51264876",
"0.50322986",
"0.50084907",
"0.4935301",
"0.49063638",
"0.48907402",
"0.48814934",
"0.48217684",
"0.48150674",
"0.48144037",
"0.48021117",
"0.47568566",
"0.4754652",
"... | 0.73624575 | 0 |
simulates a universe and uses playground.choose_trial to take a decision return true in cas of survival in the simulated universe | def simulate_universe():
# untreated_survival is the probability to survive if not treated
# this is an exact law of the universe, the player will not have this information
untreated_survival = random.uniform(MIN_DISEASE_SURVIVAL, MAX_DISEASE_SURVIVAL)
trials: list[Trial] = []
treated_survivals: dict[Trial, float] = {}
for _ in range(random.randint(MIN_TREATMENTS_COUNT, MAX_TREATMENTS_COUNT)):
group_size = random.randint(MIN_GROUP_SIZE, MAX_GROUP_SIZE)
# treated_survival is the probability to survive if treated
# this is an exact law of the universe, the player will not have this information
# therefore it is stored in a separate dict and not in the given-to-player Trial object
treated_survival = random.uniform(MIN_TREATED_SURVIVAL, MAX_TREATED_SURVIVAL)
trial = Trial(group_size, untreated_survival, treated_survival)
trials.append(trial)
treated_survivals[trial] = treated_survival
chosen_trial = playground.choose_trial(trials)
if chosen_trial is None: # None means no treatment
chosen_survival = untreated_survival
else:
chosen_survival = treated_survivals[chosen_trial]
return random.uniform(0, 1) <= chosen_survival | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_run_sim_1():\n rnd = rand.Arrivals(36, 41)\n sim.run_sim(3, 2, 5, 6, 22, rnd)",
"def run_trial():\n env = gym.make('CartPole-v0')\n obs_dim = env.observation_space.shape[0]\n n_actions = env.action_space.n\n\n qnet = QNet(obs_dim, n_actions)\n agent = Sarsa(qnet, n_actions, 0.99, 1.... | [
"0.6240639",
"0.6103099",
"0.60925263",
"0.5984078",
"0.5937608",
"0.5916742",
"0.5768528",
"0.5740173",
"0.5682504",
"0.5681896",
"0.56587714",
"0.56468713",
"0.5616107",
"0.56043226",
"0.5596143",
"0.5585067",
"0.558289",
"0.5577875",
"0.5572243",
"0.55598336",
"0.55593103"... | 0.799685 | 0 |
Does the same thing as the simulate_universes function but do not use playground.choose_trial. Instead of using trials, it takes a decision according to the real (secret) treatment survival. The obtained score is the score you obtain if you know all the variables and not only the trials facts | def compute_god_score():
survivals_count = 0
for _ in range(PARALLEL_UNIVERSES_COUNT):
best_survival = random.uniform(MIN_DISEASE_SURVIVAL, MAX_DISEASE_SURVIVAL)
for _ in range(random.randint(MIN_TREATMENTS_COUNT, MAX_TREATMENTS_COUNT)):
treated_survival = random.uniform(MIN_TREATED_SURVIVAL, MAX_TREATED_SURVIVAL)
if treated_survival > best_survival:
best_survival = treated_survival
if random.uniform(0, 1) <= best_survival:
survivals_count += 1
return survivals_count / PARALLEL_UNIVERSES_COUNT | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_universe():\n\n # untreated_survival is the probability to survive if not treated\n # this is an exact law of the universe, the player will not have this information\n untreated_survival = random.uniform(MIN_DISEASE_SURVIVAL, MAX_DISEASE_SURVIVAL)\n\n trials: list[Trial] = []\n\n treate... | [
"0.7318751",
"0.63951796",
"0.609098",
"0.593011",
"0.58897114",
"0.5845657",
"0.583531",
"0.58247733",
"0.5823327",
"0.5815546",
"0.57771176",
"0.5770173",
"0.5762508",
"0.57173645",
"0.5677805",
"0.56669015",
"0.56631994",
"0.5633992",
"0.5622041",
"0.5611543",
"0.5583957",... | 0.5252823 | 47 |
Method gets user credential from storage JSON file If credential are not in storage or are invalid, gets new credentials If stored credential are expired, refreshes them | def get_credentials(self, **kwargs):
creds_file = os.path.join(kwargs['user_dir'], 'credentials.json')
# Getting credentials from Storage
store = file.Storage(creds_file)
creds = store.get()
# Validating or refreshing credentials, if necessary
if creds is None or creds.invalid:
flow = client.flow_from_clientsecrets(self.client_secret_file,
self.scopes)
creds = tools.run_flow(flow, store)
elif creds.access_token_expired:
creds.refresh(httplib2.Http())
else:
pass
return creds | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_user_credentials(self, storage):\n # Set up a Flow object to be used if we need to authenticate.\n flow = client.flow_from_clientsecrets(\n self.client_secrets,\n scope=self.api_scopes,\n message=tools.message_if_missing(self.client_secrets))\n\n # Re... | [
"0.7427812",
"0.7198125",
"0.71123177",
"0.7038576",
"0.7036431",
"0.7013569",
"0.6985227",
"0.69778216",
"0.6926867",
"0.6853255",
"0.683662",
"0.676247",
"0.6717914",
"0.6712703",
"0.6711394",
"0.6686284",
"0.66799074",
"0.66706616",
"0.6668772",
"0.66675913",
"0.6653017",
... | 0.70376235 | 4 |
Equal width bin, take a uniform distribution for the sample value range. Buckets include the right boundary, and exclude the left boundary. Namely, boundaries=[0., 1., 2.] generates buckets (inf, 0.], (0., 1.], (1., 2.], and (2., +inf) | def uniform(feature, bins):
t = (feature.max()-feature.min())/bins
return [t*i for i in range(1, bins)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_bucket_boundaries(self):\n\n lower = self._lower_bounds[0]\n for i in xrange(1, self.total_buckets):\n upper = self._lower_bounds[i]\n yield (lower, upper)\n lower = upper\n\n yield (lower, float('Inf'))",
"def bucket_boundaries(self, bucket):\n\n if bucket < 0 or bucket >= sel... | [
"0.6999874",
"0.6858696",
"0.67939454",
"0.6425844",
"0.64145726",
"0.63430184",
"0.6245302",
"0.6230007",
"0.6219566",
"0.62046456",
"0.618017",
"0.61405003",
"0.61358374",
"0.61317116",
"0.6131306",
"0.6127178",
"0.60743845",
"0.6071009",
"0.6056603",
"0.6021089",
"0.598096... | 0.62419814 | 7 |
Equal frequency bin, take a uniform distribution of the sample size. Buckets include the right boundary, and exclude the left boundary. Namely, boundaries=[0., 1., 2.] generates buckets (inf, 0.], (0., 1.], (1., 2.], and (2., +inf). | def quantile(feature, bins):
t = feature.sort_values().values
w = round(len(t)/bins)
return [t[w*i-1] for i in range(1, bins)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bins(self):\n min_val = 0\n max_val = 1\n buckets = 10\n values_per_bucket = 10\n\n import numpy\n\n data = list(numpy.linspace(min_val, max_val, buckets * values_per_bucket))\n bins = numpy.linspace(min_val, max_val + sys.float_info.epsilon, buckets + 1)\n... | [
"0.68158084",
"0.6405568",
"0.6296729",
"0.62813383",
"0.62101144",
"0.61591256",
"0.61568004",
"0.6148516",
"0.61107266",
"0.60635036",
"0.60612935",
"0.60541433",
"0.60541433",
"0.60535467",
"0.60273194",
"0.5927287",
"0.5926463",
"0.59147674",
"0.58974785",
"0.5892863",
"0... | 0.0 | -1 |
Probability grouping of category variables | def probability_categorical(feature, label):
assert feature.nunique()>2, 'feature category nums must be greater than 2.'
t = pd.DataFrame({'feature':feature, 'label':label})
cat = label.unique()
cat = [(cat[i], cat[i+1]) for i in range(len(cat)-1)]
prob = label.value_counts(1).to_dict()
slope = [prob.get(i[0], 0)-prob.get(i[1], 0) for i in cat]
slope_dict = t.feature.value_counts(1).to_dict()
prob = t.groupby([ 'feature']).label.value_counts(1).to_dict()
slope_dict = {i:{'category_rate':slope_dict[i], 'slope':[prob.get((i,j[0]), 0)-prob.get((i,j[1]), 0) for j in cat]} for i in slope_dict}
for i in slope_dict:
slope_dict[i]['slope_diff'] = sum([abs(slope[j]-slope_dict[i]['slope'][j]) for j in range(len(slope))])
value1 = sorted([[[i], slope_dict[i]['slope_diff'], slope_dict[i]['category_rate']] for i in slope_dict], key=lambda x:x[1], reverse=1)
distance = sorted([value1[i][1]-value1[i+1][1] for i in range(len(value1)-1)])
std = pd.Series([i[1] for i in value1]).std()
coupe = value1
dis = distance[0]
for k in distance:
value = value1
while 1:
for i in range(len(value)-1):
if value[i][1]-k<value[i+1][1]:
value[i+1][0] = value[i][0]+value[i+1][0]
value[i+1][1] = value[i][1]*value[i][2]/(value[i][2]+value[i+1][2])+value[i+1][1]*value[i+1][2]/(value[i][2]+value[i+1][2])
value[i+1][2] = value[i][2]+value[i+1][2]
value.remove(value[i])
break
if i==len(value)-2:
break
if pd.Series([i[1] for i in value]).std()>std:
coupe = value
std = pd.Series([i[1] for i in value]).std()
dis = k
return {'group':{k:i for i,j in enumerate(coupe) for k in j[0]}, 'data':coupe,
'distance':dis, 'distance_index':f'{distance.index(dis)+1}/{len(distance)}', 'std':std} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ppf(self,x):\n return self.categoricalDist.ppf(x)",
"def calc_priors(categories, data):\n counts = np.zeros(categories)\n for val in range(categories):\n counts[val] = np.count_nonzero(data.labels == val)\n return counts / len(data.labels)",
"def categorical(pvals: np.ndarray) -> int:\n\... | [
"0.6292472",
"0.6147138",
"0.60119295",
"0.59831697",
"0.5894537",
"0.5834089",
"0.5826",
"0.57258606",
"0.5708978",
"0.5685781",
"0.56797826",
"0.5673375",
"0.5663211",
"0.56225026",
"0.55870885",
"0.5568914",
"0.55597067",
"0.5559275",
"0.5555052",
"0.5546693",
"0.55196595"... | 0.70440626 | 0 |
Convert time_offsets to gps timestamps and nanoseconds | def get_gps_timestamp(file, time_offset):
reference_date = get_reference_datetime(file)
absolute_date = get_absolute_datetime(reference_date, time_offset)
timestamp, nanosecond = datetime_to_gpstimestamp_nanoseconds(absolute_date)
return timestamp, nanosecond | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_gps_time(self):\n reason = \"[!] GPS timestamps are 10 digits\"\n ts_type = self.ts_types['gpstime']\n try:\n if not len(self.gps) == 10 or not self.gps.isdigit():\n self.in_gpstime = indiv_output = combined_output = False\n pass\n e... | [
"0.6133533",
"0.5981217",
"0.5839412",
"0.5720046",
"0.5719699",
"0.5716344",
"0.5671996",
"0.56716424",
"0.56283784",
"0.5613697",
"0.55957836",
"0.55948985",
"0.55543983",
"0.5532485",
"0.55197525",
"0.54900724",
"0.54886615",
"0.54784024",
"0.5435569",
"0.5418071",
"0.5407... | 0.674219 | 0 |
Convert datetime objects to GPS timestamp and nanoseconds | def datetime_to_gpstimestamp_nanoseconds(date):
timestamp = gpstime.utc_to_gps(calendar.timegm(date.utctimetuple()))
nanosecond = date.microsecond * 1000
return timestamp, nanosecond | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_gps_time(self):\n ts_type = self.ts_types['gpstime']\n try:\n leapseconds = self.leapseconds\n check_date = duparser.parse(self.timestamp)\n if hasattr(check_date.tzinfo, '_offset'):\n dt_tz = check_date.tzinfo._offset.total_seconds()\n ... | [
"0.64110595",
"0.6309177",
"0.6237445",
"0.61667824",
"0.61475044",
"0.61468357",
"0.6086212",
"0.606989",
"0.6046954",
"0.60396606",
"0.6038311",
"0.60068566",
"0.59911877",
"0.5953865",
"0.59505874",
"0.5947502",
"0.5941145",
"0.5941145",
"0.5921453",
"0.591261",
"0.5876311... | 0.7270666 | 0 |
Get the absolute time of the discharges | def get_absolute_datetime(reference, offset):
absolute_datetime = reference + datetime.timedelta(seconds=offset)
return absolute_datetime | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getChargeTime(self):\n return self.json_state.get(\"charging\").get(\"seconds_charging\")",
"def get_ref_time(self):\n from datetime import datetime, timedelta\n\n ref_time = datetime(2010, 1, 1, 0, 0, 0)\n ref_time += timedelta(seconds=int(self.fid['/PRODUCT/time'][0]))\n ... | [
"0.6573679",
"0.65164846",
"0.6515013",
"0.6418441",
"0.6405775",
"0.63922805",
"0.6391688",
"0.6354492",
"0.6346032",
"0.6239634",
"0.62149274",
"0.6191225",
"0.6191107",
"0.61854005",
"0.6183254",
"0.6182833",
"0.61757195",
"0.61671525",
"0.6158372",
"0.61397165",
"0.610876... | 0.0 | -1 |
Get the reference datetime from the KNMI LGT file as datetime | def get_reference_datetime(file):
date_string = file.root.discharge1._f_getAttr('reference_datetime')[0]
ref_date = datetime.datetime.strptime(date_string, '%d-%b-%Y;%H:%M:%S.%f')
return ref_date | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ref_time(self):\n from datetime import datetime, timedelta\n\n ref_time = datetime(2010, 1, 1, 0, 0, 0)\n ref_time += timedelta(seconds=int(self.fid['/PRODUCT/time'][0]))\n return ref_time",
"def get_file_date(self, file: str) -> date:",
"def extract_datetime(fpath):\n tr... | [
"0.6449726",
"0.6254226",
"0.6224529",
"0.6155637",
"0.6119671",
"0.61154586",
"0.6110254",
"0.5968073",
"0.59634435",
"0.5960696",
"0.59445274",
"0.5924622",
"0.59102046",
"0.5850813",
"0.57510024",
"0.574005",
"0.574005",
"0.5737356",
"0.57372004",
"0.5716487",
"0.5684267",... | 0.7556686 | 0 |
get all orders and find the time span if order have been prepared , the ticchen's name will store in the orderdata | def cook_order_list(request):
all_orders = Order.objects.all().order_by("-id")
css = CookStatus.objects.filter(cook_name=request.user)
cs = None
current_order = None
if len(css) != 0:
cs = css[0]
if cs.current_order != None :
current_order = cs.current_order.menu_items.all()
new_orders = []
for order in all_orders:
a = {}
a['id'] = order.id
a['status'] = order.status
a['timespan'] = (datetime.datetime.utcnow().replace(tzinfo=utc) - order.timestamp_created).seconds
cookofthis = CookStatus.objects.filter(current_order=order)
if len(cookofthis) != 0:
a['cookname'] = cookofthis[0].cook_name.username
elif order.tikchen != None:
a['cookname'] = order.tikchen
new_orders.append(a)
return render_to_response('staff/cook_order_list.html',
{'all_orders':new_orders, 'user':request.user, 'current_order':current_order}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trackOrderRequest(self):\n\t\tstart_dat=datetime.today()\n\t\tstart_date = start_dat - timedelta( hours=start_dat.time().hour,minutes=start_dat.time().minute,seconds=start_dat.time().second ) \n\t\tend_date=start_dat\n\t\tans=None\n\t\t#print start_dat.time().hour\n\t\tprint end_date\n\t\tans=Order.objects.fil... | [
"0.67804915",
"0.66184914",
"0.60975254",
"0.60764414",
"0.6066185",
"0.5877417",
"0.58634293",
"0.58248085",
"0.57850134",
"0.57413775",
"0.5655956",
"0.5629255",
"0.55018866",
"0.5500083",
"0.54759413",
"0.54736453",
"0.54555213",
"0.544849",
"0.5419155",
"0.53935933",
"0.5... | 0.5067255 | 46 |
chang the order's status to be "cooking" which is selected by the id of order | def cook_order(request):
order_id = request.GET.get('order_id', 0)
cs , status = CookStatus.objects.get_or_create(cook_name=request.user)
if cs.current_order is None:
cs.current_order = Order.objects.get(id=order_id)
cs.current_order.status = 'cooking'
cs.current_order.tikchen = request.user.username
cs.current_order.save()
cs.save()
return HttpResponseRedirect("/staff/cook_order_list/") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def order_ready(request):\n\tcs , status = CookStatus.objects.get_or_create(cook_name=request.user)\n\tif cs.current_order is not None:\n\t\tcs.current_order.status = 'ready-to-serve'\n\t\tcs.current_order.save()\n\t\tcs.current_order = None\n\t\tcs.save()\n\n\treturn HttpResponseRedirect(\"/staff/cook_order_list/... | [
"0.63635933",
"0.586669",
"0.5858225",
"0.58000624",
"0.56946445",
"0.5581705",
"0.55623066",
"0.55381656",
"0.5464021",
"0.5398148",
"0.53747994",
"0.5373412",
"0.53628695",
"0.5324506",
"0.5319295",
"0.52873236",
"0.5282698",
"0.52594453",
"0.5258599",
"0.52334434",
"0.5232... | 0.7182565 | 0 |
chang the order's status to be "readytoserve" which is selected by the id of order | def order_ready(request):
cs , status = CookStatus.objects.get_or_create(cook_name=request.user)
if cs.current_order is not None:
cs.current_order.status = 'ready-to-serve'
cs.current_order.save()
cs.current_order = None
cs.save()
return HttpResponseRedirect("/staff/cook_order_list/") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def update_order_status():\n symbol = App.config[\"symbol\"]\n\n # Get currently active order and id (if any)\n order = App.order\n order_id = order.get(\"orderId\", 0) if order else 0\n if not order_id:\n log.error(f\"Wrong state or use: check order status cannot find the order id.\")\... | [
"0.67920375",
"0.670818",
"0.66758204",
"0.6641249",
"0.65196955",
"0.6437769",
"0.6087314",
"0.6031311",
"0.5999321",
"0.59882295",
"0.5978718",
"0.5966084",
"0.59375423",
"0.59296644",
"0.59227234",
"0.5900806",
"0.58614755",
"0.5841006",
"0.5841006",
"0.58058894",
"0.57958... | 0.68117625 | 0 |
Format trajectory into a list of tuples before they are stored in memory. Trajectory is list of (s,a,r,s,d) tuples | def formatTrajectory(self, trajectory):
return self.RLModel.formatTrajectory(trajectory) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_trajectory(path: str) -> Optional[List[Dict[str, tuple]]]:\n lines = _get_lines_from_file(path)\n\n ess_file = False\n if path.split('.')[-1] != 'xyz':\n try:\n log = ess_factory(fullpath=path, check_for_errors=False)\n ess_file = True\n except (InputError, RM... | [
"0.60951096",
"0.6015128",
"0.5985093",
"0.5921288",
"0.5903913",
"0.5848871",
"0.5752752",
"0.5743873",
"0.5734865",
"0.5705948",
"0.56735694",
"0.5643993",
"0.55531675",
"0.5550036",
"0.55357385",
"0.5534374",
"0.550818",
"0.5483543",
"0.5480718",
"0.5441098",
"0.5439881",
... | 0.6233229 | 0 |
This function will be use to train model and save model for given training set. | def train(X_train, y_train, save_model='model.h5'):
# Hyperparameters
batch_size = 32
epochs = 30
learning_rate = 0.001
# Loading model from model.py
model = m(input_height=IMAGE_HEIGHT, input_width=IMAGE_WIDTH)
# Plot model as image
plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
# If trained model exist already then load first for further training
if tf.gfile.Exists(save_model):
model.load_weights(save_model)
model.compile(loss='mse', optimizer=Adam(learning_rate))
# Only save model which has best performed on validation set.
# These are callbacks which are being used in "model.fit" call
earlyStopping = EarlyStopping(monitor='val_loss', patience=5, verbose=1, mode='min')
mcp_save = ModelCheckpoint('model.h5', save_best_only=True, monitor='val_loss', mode='min')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, epsilon=1e-4, mode='min')
# Train the model
model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[earlyStopping, mcp_save, reduce_lr_loss], validation_split=0.2, shuffle=True)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainAndSaveModels():\n print \"\\nTraining models...\"\n\n #Use the best-performed train and test splitted data \n X_train = pickle.load(open('X_train.sav','rb'))\n X_test = pickle.load(open('X_test.sav','rb'))\n Y_train = pickle.load(open('Y_train.sav','rb'))\n \n #train models\n lass... | [
"0.7705048",
"0.74385786",
"0.7426859",
"0.7407801",
"0.7267371",
"0.7208689",
"0.71939373",
"0.71755517",
"0.71754044",
"0.7151909",
"0.7151358",
"0.7147768",
"0.7145118",
"0.7128991",
"0.71117663",
"0.7085029",
"0.7073787",
"0.7053388",
"0.70399153",
"0.70298266",
"0.702379... | 0.7325195 | 4 |
Base class for Python RL environments. | def __init__(self, handle_auto_reset: bool = False):
self._handle_auto_reset = handle_auto_reset
self._current_time_step = None
common.assert_members_are_not_overridden(
base_cls=PyEnvironment, instance=self, denylist=('reset', 'step')
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self): \n\t\n\t # get the environment\n\t\tself.env = env()",
"def __init__(self, env):\n gym.Wrapper.__init__(self, env)",
"def __init__(self, env):\n gym.Wrapper.__init__(self, env)",
"def __init__(self, env):\n super().__init__(env)",
"def __init__(self, env):\n ... | [
"0.68557495",
"0.66981584",
"0.66981584",
"0.66636485",
"0.66636485",
"0.66636485",
"0.6464115",
"0.616451",
"0.6071239",
"0.5907203",
"0.589397",
"0.58922243",
"0.58735794",
"0.58711684",
"0.58711684",
"0.58711684",
"0.58711684",
"0.58711684",
"0.58711684",
"0.5841212",
"0.5... | 0.0 | -1 |
Whether the environment is batched or not. If the environment supports batched observations and actions, then overwrite this property to True. A batched environment takes in a batched set of actions and returns a batched set of observations. This means for all numpy arrays in the input and output nested structures, the first dimension is the batch size. When batched, the leftmost dimension is not part of the action_spec or the observation_spec and corresponds to the batch dimension. When batched and handle_auto_reset, it checks `np.all(steps.is_last())`. | def batched(self) -> bool:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_size(self) -> Optional[int]:\n if self.batched:\n raise RuntimeError(\n 'Environment %s marked itself as batched but did not override the '\n 'batch_size property'\n % type(self)\n )\n return None",
"def is_batch():\n\n pass",
"def _global_batch_size(self... | [
"0.6829763",
"0.63745177",
"0.6135504",
"0.6097213",
"0.60270363",
"0.59971696",
"0.5886409",
"0.5588769",
"0.5547144",
"0.55365115",
"0.5511294",
"0.55018145",
"0.5477585",
"0.5467263",
"0.54394144",
"0.5351245",
"0.53225625",
"0.53225625",
"0.53225625",
"0.53225625",
"0.529... | 0.6470478 | 1 |
The batch size of the environment. | def batch_size(self) -> Optional[int]:
if self.batched:
raise RuntimeError(
'Environment %s marked itself as batched but did not override the '
'batch_size property'
% type(self)
)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_size(self):\n return self.size",
"def batch_size(self):\n return self._batch_size",
"def batch_size(self):\n return self._batch_size",
"def batch_size(self):\n return self._batch_size",
"def batch_size(self):\n return self._batch_size",
"def get_batch_size():\... | [
"0.8748392",
"0.8526226",
"0.8526226",
"0.8526226",
"0.8526226",
"0.8332826",
"0.82787216",
"0.82280636",
"0.8090263",
"0.8073407",
"0.80665404",
"0.80136347",
"0.8010651",
"0.8002175",
"0.8002175",
"0.8002175",
"0.8002175",
"0.7821338",
"0.7717743",
"0.76162803",
"0.75835013... | 0.7726753 | 18 |
Whether the Environmet should reset given the current timestep. By default it only resets when all time_steps are `LAST`. | def should_reset(self, current_time_step: ts.TimeStep) -> bool:
handle_auto_reset = getattr(self, '_handle_auto_reset', False)
return handle_auto_reset and np.all(current_time_step.is_last()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_values(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"reset_values\")",
"def reset():\n return True",
"def reset_values(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"reset_values\")",
"def reset(self, **kwargs):\n if self._backend_ag... | [
"0.6065845",
"0.5846722",
"0.5738438",
"0.57173324",
"0.5702698",
"0.5700601",
"0.56152225",
"0.5585178",
"0.55754685",
"0.5555264",
"0.5542493",
"0.55404925",
"0.5514392",
"0.5394026",
"0.5376499",
"0.5355567",
"0.53485197",
"0.53262925",
"0.5297183",
"0.52819175",
"0.528191... | 0.8290577 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.