def __init__(self, args, env, env_params): self.args = args self.env = env self.env_params = env_params # create the network self.actor_network = actor(env_params) self.critic_network = critic(env_params) # sync the networks across the cpus sync_networks(self.actor_network) sync_networks(self.critic_network) # build up the target network self.actor_target_network = actor(env_params) self.critic_target_network = critic(env_params) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda and torch.cuda.is_available(): self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module = her_sampler(self.args.replay_strategy, self.args.replay_k, self.env.compute_reward) # create the replay buffer self.buffer = replay_buffer(self.env_params, self.args.buffer_size, self.her_module.sample_her_transitions) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.g_norm = normalizer(size=env_params['goal'], default_clip_range=self.args.clip_range) # add tensorboardX tool # create the dict for store the model if MPI.COMM_WORLD.Get_rank() == 0: if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name) if not os.path.exists(self.model_path): os.mkdir(self.model_path) print('model path', self.model_path) # self.writer = SummaryWriter('./logs') self.reward_list = [] self.reward_record = [] self.success_rate_list = [] self.success_list = []
def scrap_ratings(doctor_url): comments = list() r = requests.get(doctor_url) if r.status_code != 200: raise Exception(f"Request error: {r.status_code}") soup = BeautifulSoup(r.text, "html.parser") try: section = soup.find("div", { "class": "col-12 bg-white rounded-15 py-3 class-46" }).find_all("div", {"class": "col-12"}) except: return comments for row in section: rating = int( re.findall(r'class="red" style="width: (\d+)', str(row))[0]) / 20 comment = re.findall(r"<\/div> <\/div> <\/div> <\/div>([\s\S]+)<small", str(row))[0] comment = re.sub(r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment.strip())) comments.append([comment, rating]) return comments
def data_load(Config): path = Config['data_set'] text = open(path).read() text = normalizer(text) print('courpus length:', len(text)) chars = set(text) print('total chars:', len(chars)) char_indices = dict((c, i) for i, c in enumerate(chars)) indices_char = dict((i, c) for i, c in enumerate(chars)) maxlen = 20 step = 3 sentences = [] next_chars = [] for i in range(0, len(text) - maxlen, step): sentences.append(text[i:i + maxlen]) next_chars.append(text[i + maxlen]) print('nb sequences:', len(sentences)) print('vectorization...') X = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool) y = np.zeros((len(sentences), len(chars)), dtype=np.bool) for i, sentence in enumerate(sentences): for t, char in enumerate(sentence): X[i, t, char_indices[char]] = 1 y[i, char_indices[next_chars[i]]] = 1 return (chars, char_indices, indices_char, maxlen, X, y, text)
def crawl_linetoday(file): norm = normalizer() txt = loadtxt(file) txt = txt.replace("><", ">\n<") txt_list = txt.split("\n") result = "" idx_t = 0 is_write = 0 for t in txt_list: if '<p class="comm">' in t: if "</p>" not in t: t = txt_list[idx_t + 1] t = t.replace('<p class="comm">', "") idx = 0 while '</p>' not in t[idx:(idx + 4)]: if t[idx] == "<": is_write += 1 elif t[idx] == ">": is_write -= 1 if is_write == 0 and t[idx] != ">": result += t[idx].lower() idx += 1 result += "\n" idx_t += 1 result = norm.normalize_text(result) result = norm.clean_text(result) savetxt(result, "norm_" + file) return (result != '')
def scrap_comments(page_id): headers = { "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "Connection": "keep-alive", "Upgrade-Insecure-Requests": "1", "Sec-GPC": "1", "Cache-Control": "max-age=0", "TE": "Trailers", } comments = [] for page_number in range(1, 25): url = f"https://taraazws.jabama.com/api/v1/reviews/place/{page_id}/reviews?page={page_number}" r = requests.get(url, headers=headers) if r.status_code != 200: raise Exception(f"request error{r.status_code}") page_comments = [] for row in json.loads(r.text)["result"]: comment = re.sub( r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(row["comment"]).strip(), ) page_comments.append([comment, row["rating"]]) if page_comments: comments += page_comments else: break return comments
def get_page_comments(url, page_number): restaurant_id = url.replace("snappfood.ir/restaurant/menu/", "").split("/")[0] comments_url = ( f"https://snappfood.ir/restaurant/comment/vendor/{restaurant_id}/{page_number}" ) r = requests.get(comments_url) if r.status_code != 200: raise Exception(f"Request Error: {r.status_code}") comments_json = json.loads(r.text)["data"] count = comments_json["count"] comments = [] for comment_dict in comments_json["comments"]: comment = re.sub( r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment_dict["commentText"]).strip(), ) rate = comment_dict["rate"] / 2 if rate == 0 and comment_dict["feeling"] == "HAPPY": rate = 5 comments.append([comment, rate]) page_comments = {"url": url, "count": count, "comments": comments} return page_comments
def scrap_comments(comment_url): ratings = list() r = requests.get(comment_url) if r.status_code != 200: raise Exception(f"request error{r.status_code}") json_data = r.json() for comment_json in json_data["pageProps"]["bookComments"]["commentsList"]: comment = re.sub( r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment_json["comment"]) ) rate = comment_json["rate"] ratings.append([comment, rate]) return ratings
def __init__(self, args, env, env_params, sample_size=100): self.args = args self.env = env self.env_params = env_params self.sample_size = sample_size # create the network self.score_predictor = open_loop_image_predictor(env_params['obs'] + env_params['action']) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.a_norm = normalizer(size=env_params['action'], default_clip_range=self.args.clip_range) # load model if load_path is not None if self.args.load_dir != '': load_path = self.args.load_dir + '/model.pt' o_mean, o_std, a_mean, a_std, model = torch.load(load_path) self.o_norm.mean = o_mean self.o_norm.std = o_std self.a_norm.mean = a_mean self.a_norm.std = a_std self.score_predictor.load_state_dict(model) # sync the networks across the cpus # sync_networks(self.score_predictor) # if use gpu if self.args.cuda: self.score_predictor.cuda() # create the optimizer self.optim = torch.optim.Adam(self.score_predictor.parameters(), lr=self.args.lr_actor) # create the replay buffer self.buffer = open_loop_buffer(self.env_params, self.args.buffer_size) # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name)
def load_data(seq_len, imf_index, ver): ts, num_req_normalize,MaxAbsScalerObj\ =normalizer.normalizer(imf_index,ver,plot=False) sequence_length = seq_len + 1 # %%%%%%%%%%%% Num Of Req %%%%%%%%%%%%%%%%%%%%%%% result = [] for index in range(len(num_req_normalize) - sequence_length): ## looks like a moving avg !!! result.append(num_req_normalize[index:index + sequence_length]) result = np.array(result) print('------------') print('shape of sequense created is ', result.shape) # (len(total_data)-seq_length) * seq_length print('length of each sequence is ', len(result[0])) print('------------') ts = ts[:result.shape[0] - 1] row = round(0.9 * result.shape[0]) train = result[:int(row), :] np.random.shuffle(train) x_train = train[:, :-1] ts_train = ts[:int(row)] y_train = train[:, -1] x_test = result[int(row):, :-1] y_test = result[int(row):, -1] ts_test = ts[int(row) - 1:] y_train_original_part = num_req_normalize[:int(row)] l = len(result) l_train = x_train.shape l_test = x_test.shape print('total data length is :', l) print('train set length : ', l_train) print('test set length :', l_test) x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) # make 3D x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) return [ x_train, y_train, y_train_original_part, x_test, y_test, ts_train, ts_test, MaxAbsScalerObj ]
def load_data(seq_len): ts, num_req_normalize, minMaxScaler\ =normalizer.normalizer(plot=True) sequence_length = seq_len + 1 # %%%%%%%%%%%% Num Of Req %%%%%%%%%%%%%%%%%%%%%%% result = [] for index in range(len(num_req_normalize) - sequence_length): ## looks like a moving avg !!! result.append(num_req_normalize[index:index + sequence_length]) result = np.array(result) print('------------') print('shape of sequense created is ', result.shape) # (len(total_data)-seq_length) * seq_length print('length of each sequence is ', len(result[0])) print('------------') ts = ts[:result.shape[0] - 1] row = round(0.9 * result.shape[0]) train = result[:int(row), :] np.random.shuffle(train) x_train = np.squeeze(train[:, :-2]) ts_train = ts[:int(row)] y_train = np.squeeze(train[:, -2:]) x_test = np.squeeze(result[int(row):, :-2]) y_test = np.squeeze(result[int(row):, -2:]) ts_test = ts[int(row) - 1:] y_train_original_part = num_req_normalize[:int(row)] l = len(result) print('total data length is :', l) print('train set length : ', x_train.shape, y_train.shape) print('test set length :', x_test.shape, y_test.shape) print('\n------------------------------------------\n\n\n\n') x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) # make 3D x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) return [ x_train, y_train, y_train_original_part, x_test, y_test, ts_train, ts_test, minMaxScaler ]
def scrap_comments(url): comments = [] package_name = url.split("/")[-1] cafebazaar_api_url = "https://api.cafebazaar.ir/rest-v1/process/ReviewRequest" headers = { "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0", "Accept": "application/json, text/plain, */*", "Accept-Language": "en-US,en;q=0.5", "Content-Type": "application/json;charset=utf-8", "Origin": "https://cafebazaar.ir", "Connection": "keep-alive", "Referer": "https://cafebazaar.ir/", "Sec-GPC": "1", "TE": "Trailers", } for start in range(0, 2_500, 100): page_comments = [] data = f'{{"properties":{{"language":2,"clientID":"m7dywtvvb5z3kph88shahoou39y8w5jw","deviceID":"m7dywtvvb5z3kph88shahoou39y8w5jw","clientVersion":"web"}},"singleRequest":{{"reviewRequest":{{"packageName":"{package_name}","start":{start},"end":{start+100}}}}}}}' for retry in range(10): r = requests.post(cafebazaar_api_url, headers=headers, data=data) if r.status_code == 200: commnets_json = json.loads(r.text) for review in commnets_json["singleReply"]["reviewReply"]["reviews"]: comment = re.sub( r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(review["comment"]).strip(), ) page_comments.append([comment, review["rate"]]) break elif r.status_code == 504: pass else: raise Exception(f"Request Error: {r.status_code}") if page_comments: comments += page_comments else: break
def scrap_all_rattings(pages_url): visited_urls = [] pages_url = [list(row) for row in pages_url] random.shuffle(pages_url) with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor: future_to_url = {} futures = [] for _, url, is_visited in pages_url: if not is_visited: futures_executor = executor.submit(scrap_rattings, url=url) future_to_url.update({futures_executor: url}) futures.append(futures_executor) for future in tqdm( concurrent.futures.as_completed(futures), initial=len(pages_url) - len(futures), total=len(pages_url), ): url = future_to_url[future] try: ratings = future.result() except Exception as exc: tqdm.write(f"{url} generated an exception: {exc}") else: if url not in visited_urls: with DimnaDatabase(db_path, logger) as db: db.update_page_visit_status( base_url, url, True, ) for comment, rate in ratings: # Regex replace multiple punctuations and normalize comment = re.sub(r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment)) db.insert_rating( base_url, comment, rate, ) visited_urls.append(url)
def draw_relevance(self, data1, data2, data1_name, data2_name): norm = normalizer() data1_norm = norm.linear_normalize(data1) data2_norm = norm.linear_normalize(data2) plt.figure(1) plt.subplot(211) plt.plot(data1, 'b-', data2, 'r-') plt.legend([data1_name, data2_name], loc="upper left") plt.subplot(212) plt.plot(data1_norm, 'b-', data2_norm, 'r-') plt.legend([data1_name, data2_name], loc="upper left") plt.grid(True) plt.show() return
def scrap_comments(course_url): id = re.findall(r"mk(\d+)", course_url)[0] page_number = 1 comments_url = f"https://maktabkhooneh.org/course/{id}/more_reviews/{page_number}/" ratings = list() r = requests.get(comments_url) if not "تا کنون نظری برای این دوره ثبت نشده است" in r.text: soup = BeautifulSoup(r.text, "html.parser") try: number_of_pages = int( max( re.findall( r"\d+", str(soup.find("div", {"class", "filler left-aligned"}))))) except: number_of_pages = 1 for page_number in range(1, number_of_pages + 1): comments_url = ( f"https://maktabkhooneh.org/course/{id}/more_reviews/{page_number}/" ) r = requests.get(comments_url) if r.status_code != 200: raise Exception(f"Request Error: {r.status_code}") soup = BeautifulSoup(r.text, "html.parser") for comment_part in soup.find_all("div", class_="comments__field"): comment = comment_part.find( "div", {"class", "comments__desc-user top-margin"}).text.strip() comment = re.sub(r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment)) rate = len( comment_part.find_all( "i", {"class", "svg-icon--24 svg-icon--gold"})) ratings += [[comment, rate]] return ratings
def scrap_comments(url): cookies = { "route": "1619449476.736.583.641701", "unique-cookie": "nwRatz4P21XQoAh", "appid": "g*-*direct*-**-*", "ptpsession": "g--2212735793014068001", "srtest": "1", } headers = { "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0", "Accept": "*/*", "Accept-Language": "fa", "lang": "fa", "Content-Type": "application/json", "X-Requested-With": "XMLHttpRequest", "Connection": "keep-alive", "Referer": "https://www.snapptrip.com/%D8%B1%D8%B2%D8%B1%D9%88-%D9%87%D8%AA%D9%84/%D8%B4%DB%8C%D8%B1%D8%A7%D8%B2/%D9%87%D8%AA%D9%84-%D8%A8%D8%B2%D8%B1%DA%AF?date_from=2021-04-26&date_to=2021-04-27", "Sec-GPC": "1", "TE": "Trailers", } params = (("limit", "500"),) comments_url = "https://www.snapptrip.com/rate_review/hotel/" + url.split("?")[-1] r = requests.get(comments_url, headers=headers, params=params, cookies=cookies) soup = BeautifulSoup(r.text, "html.parser") comments = [] try: comments_li = soup.find_all("li", {"class": "comment-item box-frame"}) for li in comments_li: rating = li.find("div", {"class": "rate-badge"}).text.strip() comment = li.find("span", {"class": "comment-text-wrapper"}) if comment: comment = comment.text.strip() else: comment = "" pn_comment = li.find_all("p", {"class": "mb-0"}) if pn_comment: if "mt-lg-1" in str(pn_comment[0]): comment += "\n" + " نقاط قوت: " + pn_comment[0].text.strip() else: comment += "\n" + " نقاط ضعف:" + pn_comment[0].text.strip() try: if "mt-lg-1" in str(pn_comment[1]): comment += "\n" + " نقاط قوت: " + pn_comment[1].text.strip() else: comment += "\n" + " نقاط ضعف: " + pn_comment[1].text.strip() except: pass comment = re.sub( r"[،؟\?\.\!]+(?=[،؟\?\.\!])", "", normalizer(comment).strip(), ) comments.append([comment, rating]) except: pass return comments
def __init__(self, args, env, env_params, image=True): self.args = args self.env = env self.env_params = env_params self.image = image # create the network if self.image: self.actor_network = actor_image(env_params, env_params['obs']) self.critic_network = critic_image( env_params, env_params['obs'] + env_params['action']) else: self.actor_network = actor(env_params, env_params['obs']) self.critic_network = critic( env_params, env_params['obs'] + env_params['action']) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) # load model if load_path is not None if self.args.load_dir != '': load_path = self.args.load_dir + '/model.pt' o_mean, o_std, g_mean, g_std, model = torch.load(load_path) self.o_norm.mean = o_mean self.o_norm.std = o_std self.actor_network.load_state_dict(model) # sync the networks across the cpus # sync_networks(self.actor_network) # sync_networks(self.critic_network) # build up the target network if self.image: self.actor_target_network = actor_image(env_params, env_params['obs']) self.critic_target_network = critic_image( env_params, env_params['obs'] + env_params['action']) else: self.actor_target_network = actor(env_params, env_params['obs']) self.critic_target_network = critic( env_params, env_params['obs'] + env_params['action']) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda: self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module = her_sampler(self.args.replay_strategy, self.args.replay_k, self.env().compute_reward) # create the replay buffer self.buffer = replay_buffer(self.env_params, self.args.buffer_size, self.her_module.sample_her_transitions, image=self.image) # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name)
import psycopg2 import numpy as np import normalizer std_cpu, std_ram, mean_cpu, mean_ram, ts, \ cpu_values_normalize, \ ram_values_normalize\ =normalizer.normalizer(plot=False) import matplotlib.pyplot as plt fig = plt.figure(facecolor='white', figsize=(13.0, 8.0)) ax = fig.add_subplot(211) ax.plot(ts, cpu_values_normalize, color='red', label='CPU', alpha=0.85) plt.legend() plt.grid() plt.ylim([0, 1]) plt.ylabel('Normalized CPU Request') ax = fig.add_subplot(212) ax.plot(ts, ram_values_normalize, color='blue', label='RAM', alpha=0.85) plt.legend() plt.grid() plt.ylim([0, 1]) plt.ylabel('Normalized RAM Request') plt.xlabel('Time Symbol') # plt.savefig('REAL_100.png', format='png', dpi=800) plt.show()
def __init__(self, args, env, env_params): self.args = args self.env = env self.env_params = env_params # create the network self.actor_network = actor(env_params) self.critic_network = critic(env_params) # sync the networks across the cpus #sync_networks(self.actor_network) #sync_networks(self.critic_network) # build up the target network self.actor_target_network = actor(env_params) self.critic_target_network = critic(env_params) # Load the model if required if args.load_path != None: o_mean, o_std, g_mean, g_std, load_actor_model, load_critic_model = torch.load( args.load_path, map_location=lambda storage, loc: storage) self.actor_network.load_state_dict(load_actor_model) self.critic_network.load_state_dict(load_critic_model) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda: self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module = her_sampler(self.args.replay_strategy, self.args.replay_k, self.env.compute_reward) # create the replay buffer self.buffer = replay_buffer(self.env_params, self.args.buffer_size, self.her_module.sample_her_transitions) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.g_norm = normalizer(size=env_params['goal'], default_clip_range=self.args.clip_range) # create the dict for store the model #if MPI.COMM_WORLD.Get_rank() == 0: if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # makeup a suffix for the model path to indicate which method is used for Training #self.folder_siffix = '_' + self.args.replay_strategy + '_' + self.args.env_params.reward_type # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name) if not os.path.exists(self.model_path): os.mkdir(self.model_path) self.model_path = os.path.join(self.model_path, 'seed_' + str(self.args.seed)) if not os.path.exists(self.model_path): os.mkdir(self.model_path)
def __init__(self, args, env, env_params): self.savetime = 0 self.args = args self.env = env self.env_params = env_params # create the network self.actor_network = actor(env_params) self.critic_network = critic(env_params) # sync the networks across the cpus sync_networks(self.actor_network) sync_networks(self.critic_network) # build up the target network self.actor_target_network = actor(env_params) self.critic_target_network = critic(env_params) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda: self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module = her_sampler(self.args.replay_strategy, self.args.replay_k, self.env.compute_reward) # create the replay buffer self.buffer = replay_buffer(self.env_params, self.args.buffer_size, self.her_module.sample_her_transitions) # 是否加入示教数据 if self.args.add_demo: self._init_demo_buffer( ) # initialize replay buffer with demonstration # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.g_norm = normalizer(size=env_params['goal'], default_clip_range=self.args.clip_range) # load the data to continue the training # model_path = "saved_models/bmirobot-v3/125_True12_model.pt" # # # model_path = args.save_dir + args.env_name + '/' + str(args.seed) + '_' + str(args.add_demo) + '_model.pt' # # o_mean, o_std, g_mean, g_std, model = torch.load(model_path, map_location=lambda storage, loc: storage) # self.actor_network.load_state_dict(model) # self.o_norm.mean=o_mean # self.o_norm.std=o_std # self.g_norm.mean=g_mean # self.g_norm.std=g_std self.success_rates = [] # 记录每个epoch的成功率 # create the dict for store the model if MPI.COMM_WORLD.Get_rank() == 0: if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name) if not os.path.exists(self.model_path): os.mkdir(self.model_path)
def load_data(seq_len, mode, factor, first_plot=False): std_cpu, std_ram, mean_cpu, mean_ram, ts, \ cpu_values_normalize, \ ram_values_normalize,min_max_scaler\ =normalizer.normalizer(plot=first_plot) sequence_length = seq_len + 1 if mode == 1: # %%%%%%%%%%%% CPU %%%%%%%%%%%%%%%%%%%%%%% result = [] for index in range(len(cpu_values_normalize) - sequence_length): ## looks like a moving avg !!! result.append(cpu_values_normalize[index:index + sequence_length]) result = np.array(result) print('------------') print('shape of sequense created is ', result.shape) # (len(total_data)-seq_length) * seq_length print('length of each sequence is ', len(result[0])) print('------------') ts = ts[:result.shape[0] - 1] elif mode == 2: # %%%%%%%%%%%% RAM %%%%%%%%%%%%%%%%%%%%%%% result = [] for index in range(len(ram_values_normalize) - sequence_length): ## looks like a moving avg !!! result.append(ram_values_normalize[index:index + sequence_length]) result = np.array(result) print('------------') print('shape of sequense created is ', result.shape) # (len(total_data)-seq_length) * seq_length print('length of each sequence is ', len(result[0])) print('------------') ts = ts[:result.shape[0] - 1] row = round(factor * result.shape[0]) train = result[:int(row), :] np.random.shuffle(train) x_train = train[:, :-1] ts_train = ts[:int(row)] y_train = train[:, -1] x_test = result[int(row):, :-1] y_test = result[int(row):, -1] ts_test = ts[int(row) - 1:] if mode == 1: y_train_original_part = cpu_values_normalize[:int(row)] elif mode == 2: y_train_original_part = ram_values_normalize[:int(row)] l = len(result) l_train = x_train.shape l_test = x_test.shape print('total data length is :', l) print('train set length : ', l_train) print('test set length :', l_test) x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) # make 3D x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) return [ x_train, y_train, y_train_original_part, x_test, y_test, ts_train, ts_test, min_max_scaler ]
csvfile = sys.argv[1] if (csvfile.lower().endswith('.csv')): df = pd.read_csv(csvfile) delete = None norm = None keepPortname = False switches = ['-minmax', '-robust', '-standard'] if (not checkColumns(df)): sys.exit("csv file does not have required columns") # check for command line switches '-del' and the ones in switches are available if ('-del' in sys.argv): delete = delete_sub_500() # preserve port names if keepport switch is given if ('-keepport' in sys.argv): keepPortname = True if (any(word in sys.argv for word in switches)): index = [word in sys.argv for word in switches].index(True) switch = switches[index] norm = normalizer(switch) ip = interpolation() pc = preclean() clean(pc, ip, df, delete, norm, keepPortname) else: sys.exit("command line argument is not a csv file") else: ship_list = ships() pre_clean = preclean() interp = interpolation() norma = normalizer('-minmax') ind = 0
hostname = 'localhost' username = '******' password = '******' database = 'load_cloud' conn = psycopg2.connect(host=hostname, user=username, password=password, dbname=database) cur = conn.cursor() norm_Ver = 1 # 1 = maxAbsSclaer (-1,1) 2=minMaxSclaer (0,1) seq_lag = 10 train_factor = 0.9 ts, num_req_normalize, MaxAbsScalerObj = normalizer(norm_Ver, False) reqs = [j for i in num_req_normalize for j in i] #print(len(reqs),len(ts)) df = pd.DataFrame({'requests': np.array(reqs)}) print(df.shape) # define function for create N lags def create_lags(df, N): for i in range(N): df['Lag' + str(i + 1)] = df.requests.shift(i + 1) return df # create lags
import numpy as np import normalizer as norm from load_data import load_csv base_path = '/home/daniel/Documentos/Projetos/TCC/Normalizador/tests' # Trocar por caminho relativo do projeto. raw_data = load_csv(f'{base_path}/raw_data.csv') normalized = norm.normalizer(raw_data) np.savetxt(f'{base_path}/normalized.csv', normalized, fmt='%.8f') print(normalized)
def __init__(self, args, env, env_params): self.args = args self.env = env self.env_params = env_params # create the network self.actor_network = actor(env_params) self.critic_network = critic(env_params) # build up the target network self.actor_target_network = actor(env_params) self.critic_target_network = critic(env_params) # Load the model if required if args.load_path != None: o_mean, o_std, g_mean, g_std, load_actor_model, load_critic_model = torch.load( args.load_path, map_location=lambda storage, loc: storage) self.actor_network.load_state_dict(load_actor_model) self.critic_network.load_state_dict(load_critic_model) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda: self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module = her_sampler(self.args.replay_strategy, self.args.replay_k, self.env.compute_reward) # create the replay buffer if self.args.replay_strategy == 'future': self.buffer = replay_buffer(self.env_params, self.args.buffer_size, self.her_module.sample_her_transitions) else: self.buffer = replay_buffer( self.env_params, self.args.buffer_size, self.her_module.sample_normal_transitions) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.g_norm = normalizer(size=env_params['goal'], default_clip_range=self.args.clip_range) # create the dict for store the model if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # makeup a suffix for the model path to indicate which method is used for Training buffer_len_epochs = int( self.args.buffer_size / (env_params['max_timesteps'] * self.args.num_rollouts_per_cycle * self.args.n_cycles)) name_add_on = '' if self.args.exploration_strategy == 'pgg': if self.args.pgg_strategy == 'final': if self.args.replay_strategy == 'future': name_add_on = '_final_distance_based_goal_generation_buffer' + str( buffer_len_epochs) + 'epochs' else: name_add_on = '_final_distance_based_goal_generation_withoutHER_buffer' + str( buffer_len_epochs) + 'epochs' else: if self.args.replay_strategy == 'future': name_add_on = '_distance_based_goal_generation_buffer' + str( buffer_len_epochs) + 'epochs' else: name_add_on = '_distance_based_goal_generation_withoutHER_buffer' + str( buffer_len_epochs) + 'epochs' else: if self.args.replay_strategy == 'future': name_add_on = '_originalHER_buffer' + str( buffer_len_epochs) + 'epochs' else: name_add_on = '_originalDDPG_buffer' + str( buffer_len_epochs) + 'epochs' # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name + name_add_on) if not os.path.exists(self.model_path): os.mkdir(self.model_path) self.model_path = os.path.join(self.model_path, 'seed_' + str(self.args.seed)) if not os.path.exists(self.model_path): os.mkdir(self.model_path)
from kMeans import k_means from normalizer import normalizer from dataGenerator import dataGenerator dGen = dataGenerator() norm = normalizer() #positions on the data and normalized_data vectors refer to the same values (unnormalized and normalized). #this is designed to allow us to trace back to the original values. data = dGen.generateCartesianPoints([0, 10000], 500) normalized_data = norm.normalize_data(data, 0, 100) #Object declaration. kMeans = k_means() #Call to the clusterizer method. clusters = kMeans.clusterize(normalized_data, 5) #Plotting clusters kMeans.plotCluster(clusters, data)
import numpy as np import Read_Data import normalizer from generator import generator std_cpu, std_ram, mean_cpu, mean_ram, ts, \ cpu_values_normalize, \ ram_values_normalize=\ normalizer.normalizer(plot=True) lookback = 50 step = 1 delay = 1 batch_size = 1 # lookback = 1440 # step = 6 # delay = 144 # batch_size = 128 # ----------- RAM --------- data=np.vstack((ts,ram_values_normalize)) data=data.T print('************',data.shape) l=data.shape[0]
#!/usr/bin/env python # -*- coding: utf-8 -*- from extractor import extractor from normalizer import normalizer from converter import converter if __name__ == "__main__": results = extractor() nodes, ties = normalizer(results) converter(nodes, ties)
def __init__(self, args, envs_lst, env_params, expert_lst_dir, recurrent=True, ee_reward=True, image=True): self.args = args self.envs_lst = envs_lst self.env_params = env_params self.recurrent = recurrent self.ee_reward = ee_reward self.image = image # initialize expert self.expert_lst = [] for dir in expert_lst_dir: expert_load_path = dir + '/model.pt' o_mean, o_std, g_mean, g_std, model = torch.load(expert_load_path) expert_model = actor(env_params, env_params['obs'] + env_params['goal']) expert_model.load_state_dict(model) self.expert_lst.append({ "model": expert_model, "o_mean": o_mean, "o_std": o_std, "g_mean": g_mean, "g_std": g_std }) # create the network if self.recurrent: self.actor_network = actor_recurrent( env_params, env_params['obs'] + env_params['goal'] + env_params['action'], env_params['goal']) # self.critic_network = critic_recurrent(env_params, env_params['obs'] + env_params['goal'] + 2 * env_params['action']) else: self.actor_network = actor( env_params, env_params['obs'] + env_params['goal'] + env_params['action'], env_params['goal']) self.critic_network = critic( env_params, env_params['obs'] + 2 * env_params['goal'] + env_params['action']) # create the normalizer self.o_norm = normalizer(size=env_params['obs'], default_clip_range=self.args.clip_range) self.g_norm = normalizer(size=env_params['goal'], default_clip_range=self.args.clip_range) self.sg_norm = normalizer(size=env_params['action'], default_clip_range=self.args.clip_range) # load model if load_path is not None if self.args.load_dir != '': load_path = self.args.load_dir + '/model.pt' # o_mean, o_std, g_mean, g_std, sg_mean, sg_std, model = torch.load(load_path) o_mean, o_std, g_mean, g_std, model = torch.load(load_path) self.o_norm.mean = o_mean self.o_norm.std = o_std self.g_norm.mean = g_mean self.g_norm.std = g_std # self.sg_norm.mean = sg_mean # self.sg_norm.std = sg_std self.actor_network.load_state_dict(model) # sync the networks across the cpus sync_networks(self.actor_network) sync_networks(self.critic_network) # build up the target network if self.recurrent: self.actor_target_network = actor_recurrent( env_params, env_params['obs'] + env_params['goal'] + env_params['action'], env_params['goal']) # self.critic_target_network = critic_recurrent(env_params, env_params['obs'] + env_params['goal'] + 2 * env_params['action']) else: self.actor_target_network = actor( env_params, env_params['obs'] + env_params['goal'] + env_params['action'], env_params['goal']) self.critic_target_network = critic( env_params, env_params['obs'] + 2 * env_params['goal'] + env_params['action']) # load the weights into the target networks self.actor_target_network.load_state_dict( self.actor_network.state_dict()) self.critic_target_network.load_state_dict( self.critic_network.state_dict()) # if use gpu if self.args.cuda: self.actor_network.cuda() self.critic_network.cuda() self.actor_target_network.cuda() self.critic_target_network.cuda() # create the optimizer self.actor_optim = torch.optim.Adam(self.actor_network.parameters(), lr=self.args.lr_actor) self.critic_optim = torch.optim.Adam(self.critic_network.parameters(), lr=self.args.lr_critic) # her sampler self.her_module_lst = [ her_sampler(self.args.replay_strategy, self.args.replay_k, env.compute_reward) for env in self.envs_lst ] # create the replay buffer self.buffer_lst = [ replay_buffer(self.env_params, self.args.buffer_size, her_module.sample_her_transitions, ee_reward=True) for her_module in self.her_module_lst ] # path to save the model self.model_path = os.path.join(self.args.save_dir, self.args.env_name)
database = 'load_cloud' conn = psycopg2.connect(host=hostname, user=username, password=password, dbname=database) cur = conn.cursor() norm_Ver = 1 # 1 = maxAbsSclaer (-1,1) 2=minMaxSclaer (0,1) seq_lag = 10 train_factor = 0.9 for imf_index in range(1, 21): print(imf_index, '****************************************') ts, num_req_normalize, MaxAbsScalerObj = normalizer( imf_index, norm_Ver, False) reqs = [j for i in num_req_normalize for j in i] #print(len(reqs),len(ts)) df = pd.DataFrame({'requests': np.array(reqs)}) print(df.shape) # define function for create N lags def create_lags(df, N): for i in range(N): df['Lag' + str(i + 1)] = df.requests.shift(i + 1) return df # create lags df = create_lags(df, seq_lag)
import numpy as np import Read_Data import normalizer from generator import generator from matplotlib import pyplot as plt imf_index = 10 # std_cpu, std_ram, mean_cpu, mean_ram, ts, ts_reload, \ # cpu_values_normalize, cpu_reloaded_normalize, \ # ram_values_normalize, ram_reloaded_normalize = \ # normalizer.normalizer(imf_index,plot=False) std_cpu,std_ram,mean_cpu,mean_ram,ts,cpu_values_normalize,ram_values_normalize = \ normalizer.normalizer(imf_index,plot=False) # # from sklearn.preprocessing import MinMaxScaler # offline_scaler = MinMaxScaler() # offline_scaler.fit(ram_values_normalize.reshape(-1, 1)) # ram_values_normalize=np.array(offline_scaler.transform(ram_values_normalize.reshape(-1, 1))) # # lookback = 100 # Observations will go back 10 days # step = 5 # Observations will be sampled at one data point per hour. # delay = 20 # Targets will be 24 hours in the future. # batch_size = 128 lookback = 360 step = 6 delay = 36