示例#1
0
    def learn(self, n_trajectories: int) -> None:
        '''Learn an optimal policy given an environment.'''

        # Simulate a series of trajectories in the environment.
        trajectories = self.simulate_n_trajectories(n_trajectories)

        # Compile the necessary information for the TRPO update.
        from ipdb import set_trace as debug
        debug()  # VALIDATE STATES INDEXING.
        states = trajectories[:, :, 0]
        actions = trajectories[:, :, 1]
        action_vectors = trajectories[:, :, 2]
        rewards = trajectories[:, :, 3]

        # TRPO update!
        theta = self.flatten_theta()

        # Compute the policy gradient -> Fx = g.
        g = self.session.run(self.policy_gradient,
                             feed_dict={
                                 self.action_vectors: action_vectors,
                                 self.actions: actions,
                                 self.states: states
                             })

        # Evaluate the natural gradient using conjugate gradient descent.
        natural_gradient = conjugate_gradient_descent(fisher_vp, g)
def image_path_to_image_id(path_to_image):
    """Convert the path to an image to a proper image_id in the new style."""
    path_list = path_to_image.split("/")
    date = path_list[-3]
    site = path_list[-2]
    image_number = path_list[-1].replace(".JPG", "")
    # Extract name of site.
    try:
        site_name = re.search(r"([\w\.\s]+)", site)[1].strip()
        site_name = site_name.replace(".", "").replace(" ", "_").lower()
        site_name = SITE_NAME_MAPPING[site_name]
    except:
        print("Cannot extract site name.")
        if site_name not in skip_sites:
            print(site_name)
            debug()
        else:
            return None
    # Extract altitude.
    try:
        altitude = re.search(r"\((\d+)\)", site)[1]
    except:
        print("Cannot extract site altitude.")
        return None
    # Extract date.
    match = re.search(DATE_REGEX, date)
    if match is None:
        print("Cannot extract data.")
        return None
    else:
        year = match[1]
        month = match[2]
        day = match[3]
    image_id = f"{year}-{month}-{day}-{site_name}-{altitude}-{image_number.replace('DJI', 'IMG')}"
    return image_id
示例#3
0
def main():
    # create the environment
    env = gym.make('FrozenLake-v0')
    # uncomment next line to try the deterministic version
    # env = gym.make('Deterministic-4x4-FrozenLake-v0')

    print_env_info(env)
    print_model_info(env, 0, lake_env.DOWN)
    print_model_info(env, 1, lake_env.DOWN)
    print_model_info(env, 14, lake_env.RIGHT)

    # input('Hit enter to run a random policy...')

    gamma = 0.9
    policy, i = rl.value_iteration(env, gamma)
    print(policy)
    policy, _, i, i = rl.policy_iteration(env, gamma)
    print(policy)
    debug()
    # total_reward, num_steps = run_policy(env, policy)
    # debug()

    total_reward, num_steps = run_random_policy(env)
    print('Agent received total reward of: %f' % total_reward)
    print('Agent took %d steps' % num_steps)
示例#4
0
文件: core.py 项目: lightscalar/pyro
 def _upsert(cls, resource_id=None):
     '''Upsert a resource. Responds to a patch to the URL.'''
     debug()
     params = assemble_params(cls, 'upsert', resource_id, request)
     data = deserialize(request.json)
     # Attempt to find the resource using query.
     matches = cls.find_where(data['query'])
     if len(matches) == 0:  # no matches
         cls._obj = cls.create(data)
         params['resp'] = cls._to_response(cls._obj._doc)
     else:
         params['resp'] = cls._to_response(matches[0])
     return (params['resp'], params['status_code'], {})
示例#5
0
def outline_to_lines(asker, root):
    debug()
    result = asker.ask(fields.get_field(cached_lines(), root)).answer
    if result is not None:
        return asker.reply(answer=result)
    base_headline = asker.ask(fields.get_field(headline(), root)).firm_answer
    root = asker.refresh(root)
    prefix = "* " if convert.check_hard(asker, is_pointer(), root) else "  "
    full_headline = strings.string_concat(T.from_str(prefix), base_headline)
    root = asker.refresh(root)
    children = asker.ask(fields.get_field(visible_children(), root)).firm_answer
    body = empty_lines()
    for child in lists.iterator(asker, children):
        section = asker.ask(outline_to_lines(child)).firm_answer
        body = concat_lines(body, section)
    result = concat_lines(one_line(full_headline), indent_lines(body))
    asker.update(updates.set_field(cached_lines(), result), root)
    return asker.reply(answer=result)
示例#6
0
def extract_tiles_from_image(
    image,
    annotations,
    tile_size=128,
    target_species=None,
    include_target=True,
    max_nb_tiles=2000,
):
    """Pull the given annotation from the image."""
    labels = []
    tiles = np.array([])
    for annotation in annotations:
        if "plant" not in annotation.keys():
            continue
        if include_target:
            if plant_to_id[annotation["plant"]] != target_species:
                continue
        else:  # require this species
            if plant_to_id[annotation["plant"]] == target_species:
                continue

        # Extract tiles, if we're still here.
        if target_species < 0:
            debug()
        col, row = annotation["col"], annotation["row"]
        col_, row_ = (
            col * 4000 / annotation["imageWidth"],
            row * 3000 / annotation["imageHeight"],
        )
        tiles_ = np.array(create_rotated_pics(image, row_, col_, tile_size, 25))
        if tiles.shape[0] > 0:
            tiles = np.vstack((tiles, tiles_))
        else:
            tiles = tiles_
        # Only return max numbers of tiles.
        if tiles.shape[0] > max_nb_tiles:
            break
    return tiles
示例#7
0
    def single_path(self) -> None:
        '''Perform a single path rollout.'''

        # Randomly sample the initial state.
        state = self.env.reset()
        from ipdb import set_trace as debug
        debug()  # LOOK AT THE STATE OBJECT.
        done = False

        # Stores (S_t, A_(t-1), AV_(t-1), R_t).
        history = [(state, -1, -1)]

        # Run a sample trajectory.
        while not done:

            # Evaluate the policy to find an action to take - A_(t-1).
            action_vectors, action = self.act(state)

            # Take the action!
            state, reward, done, info = self.env.step(action)
            history.append((state, action, action_vectors, reward))

        return np.array(history)
示例#8
0
def smart_batch(scientific_name,
                tile_size=128,
                nb_tiles_per_class=1000,
                samples_per_tile=10):
    """Generate a smart batch that balances the target against a mix of its confusors."""
    # Extract tiles associated with the primary target.
    print("> Extracting targets.")
    X, y = extract_smart_training_tiles(
        scientific_name,
        label=1,
        tile_size=tile_size,
        nb_tiles_per_class=nb_tiles_per_class,
        samples_per_tile=samples_per_tile,
    )
    # Now extract tiles from each of the confusing classes.
    confusors = CONFUSORS[scientific_name]
    nb_tiles_per_confusor = int(nb_tiles_per_class / len(confusors))
    print("> Extracting confusors.")
    for confusor in confusors:
        X_, y_ = extract_smart_training_tiles(
            confusor,
            label=0,
            tile_size=tile_size,
            nb_tiles_per_class=nb_tiles_per_confusor,
            samples_per_tile=samples_per_tile,
        )
        if X_ is not None:
            try:
                X = np.vstack((X, X_))
                y = np.hstack((y, y_))
            except:
                debug()
    idx = np.arange(X.shape[0])
    np.random.shuffle(idx)
    X = X[idx, :]
    y = y[idx]
    return X, y
示例#9
0
def plot_output_q2(ys: list = [], ts: list = [], rs: list = []) -> None:
    '''Plot the output for question 2.'''

    plt.figure()
    lines = []
    debug()
    labels = [
        'Susceptible Population', 'Infected Population', 'Recovered Population'
    ]
    titles = [fr'$\beta$ = {b[1]}' for i, b in enumerate(rs) if i % 3 == 0]
    cols = [fr'$X_0$ = {b[2]}' for b in rs]

    for i, tup in enumerate(zip(ys, ts, rs)):

        y, t, rb = tup
        S, I, R = zip(*y)
        S, I, R = np.array(S), np.array(I), np.array(R)

        plt.subplot(3, 3, i + 1)
        for var, label in zip([S, I, R], labels):
            line, = plt.plot(t, var)
            lines.append(line)

        if i < 3:
            plt.title(titles[i])

        if i % 3 == 0:
            plt.ylabel(cols[int(i / 3)])

        # plt.xlabel('Time')
        # plt.ylabel('Compartments')
        # plt.title(fr'$R_0$ = {rb[0]}, $\beta$ = {rb[1]}')
        plt.grid()

    plt.subplots_adjust(hspace=0.5)
    plt.figlegend((lines[0], lines[1], lines[2]), labels)
    plt.show()
示例#10
0
def reintroduce_modifier(asker, property, update, input, output):
    result = translator.dispatch(asker, property, update, input, output)
    if result is None:
        debug()
    return result
示例#11
0
plt.ylabel('Total Yield (1,000 $)')
plt.title('Price Of Oats vs. Total Yield')
plt.grid()

plt.subplot(3, 1, 2)
corn, wheat, oats = zip(*xopt.values())
plt.plot(oat_price_range, corn, label='Corn')
plt.plot(oat_price_range, wheat, label='Wheat')
plt.plot(oat_price_range, oats, label='Oats')
plt.xlabel('Price of Oats ($/acre)')
plt.ylabel('Crops Planted (acre)')
plt.legend(loc='lower left')
plt.title('Price of Oats vs. Crops Planted')
plt.grid()

plt.subplot(3, 1, 3)
debug()
water, labor, land = zip(*lamb.values())
plt.plot(oat_price_range, water, label='Water')
plt.plot(oat_price_range, labor, label='Labor')
plt.plot(oat_price_range, land, label='Land')
plt.legend(loc='lower left')
plt.title('Price of Oats vs. Value of Constraints')
plt.xlabel('Price of Oats ($/acre)')
plt.ylabel('Shadow Price ($/unit)')
plt.grid()

plt.subplots_adjust(hspace=0.5)

plt.show()
示例#12
0
 def ask(self, Q, handler=None, **kwargs):
     response = self.ask_func(Q, parent=self)
     if getattr(self, "slow", False):
         debug()
     return response.set(self.process_response(response.value, Q=Q, handler=handler))
示例#13
0
for tag in training_tags:
    try:
        tag_counts[tag] += 1
    except:
        tag_counts[tag] = 1

for ngram in nltk.ngrams(training_words, 2):
    training_word_ngrams.append(ngram)

for ngram in nltk.ngrams(training_tags, 2):
    training_tag_ngrams.append(ngram)

for ngram in training_tag_ngrams:
    try:
        ngram_tag_counts[ngram] += 1
    except:
        ngram_tag_counts[ngram] = 1


tag_transition_probs = {}

for tag in tag_counts:
    tag_transition_probs[tag] = {}
    for ngram in ngram_tag_counts:
        if ngram[0] != tag:
            continue
        tag_transition_probs[tag][ngram] = ngram_tag_counts[ngram] / tag_counts[ngram[0]]


debug()
示例#14
0
def map_summaries():
    """Return the map summary information."""
    flights = []
    years = glob(f"{ARGOS_ROOT}/*")
    maps = []
    for year in years:
        months = sorted(glob(f"{year}/*"))
        # print(year)
        # print(months)
        for month in months:
            days = sorted(glob(f"{month}/*"))
            for day in days:
                sites = sorted(glob(f"{day}/*"))
                for site in sites:
                    altitudes = sorted(glob(f"{site}/*"))
                    for altitude in altitudes:
                        if altitude.split("/")[-1] != "obliques":
                            images = sorted(glob(f"{altitude}/images/*.JPG"))
                            images.sort(key=os.path.getmtime)
                            nb_images = len(images)
                            if nb_images > 0:  # if no images, just why?
                                first_meta = extract_info(images[0])
                                last_meta = extract_info(images[-1])
                                start = first_meta["date_time"]
                                try:
                                    datetime_obj = datetime.strptime(
                                        start, "%Y:%m:%d %H:%M:%S"
                                    )
                                except:
                                    debug()
                                datetime_str = datetime_obj.strftime("%d %b %Y")
                                smalldate = datetime_obj.strftime("%Y-%m-%d")
                                time_str = datetime_obj.strftime("%I-%M%p")
                                alt = altitude.split("/")[-1]
                                sitename = site.split("/")[-1]
                                year_ = year.split("/")[-1]
                                month_ = month.split("/")[-1]
                                day_ = day.split("/")[-1]
                                end = last_meta["date_time"]
                                path_to_map = f"{altitude}/maps/map_small.jpg"
                                path_to_geomap = f"{altitude}/maps/map.tif"
                                path_to_images = f"{altitude}/images"
                                map_id = f"{year_}-{month_}-{day_}-{sitename}-{alt}"

                                # Get map sizes.
                                if len(glob(path_to_geomap)) == 0:
                                    continue
                                # ds = gdal.Open(path_to_geomap)
                                # geo_rows = ds.RasterYSize
                                # geo_cols = ds.RasterXSize
                                # small_map = plt.imread(path_to_map)
                                # small_rows, small_cols, _ = small_map.shape
                            else:
                                continue  # No images? Don't return this map.
                            if len(glob(f"{altitude}/maps/map.tif")) > 0:
                                maps.append(
                                    {
                                        "map_id": map_id,
                                        "year": year_,
                                        "month": month_,
                                        "day": day_,
                                        "site": sitename,
                                        "altitude": alt,
                                        "nb_images": nb_images,
                                        # "geo_rows": geo_rows,
                                        # "geo_cols": geo_cols,
                                        # "small_rows": small_rows,
                                        # "small_cols": small_cols,
                                        # "lat": f"{first_meta['img_lat']:.4f}",
                                        # "lon": f"{first_meta['img_lon']:.4f}",
                                        "start": start,
                                        "end": end,
                                        "time": time_str.replace("-", ":"),
                                        "datetime": datetime_str,
                                        "path_to_geomap": "/".join(
                                            path_to_geomap.split("/")[-7:]
                                        ),
                                        "path_to_map": "/".join(
                                            path_to_map.split("/")[-7:]
                                        ),
                                        "path_to_images": "/".join(
                                            path_to_images.split("/")[-6:]
                                        ),
                                    }
                                )
    maps = sorted(maps, key=lambda x: x["start"])
    return maps