code stringlengths 17 6.64M |
|---|
class TestPicking(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='picking')
self.env = CausalWorld(task=self.task, enable_visualization=False, skip_frame=1, action_mode='end_effector_positions', normalize_actions=False, normalize_observations=False)
retur... |
class TestPushing(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='pushing')
self.env = CausalWorld(task=self.task, enable_visualization=False)
return
def tearDown(self):
self.env.close()
return
def test_determinism(self):
... |
class TestReaching(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='reaching')
self.env = CausalWorld(task=self.task, enable_visualization=False, action_mode='joint_positions', normalize_observations=False, normalize_actions=False)
return
def tearDown... |
class TestStackedBlocks(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='stacked_blocks')
self.env = CausalWorld(task=self.task, enable_visualization=False)
return
def tearDown(self):
self.env.close()
return
def test_determinism(s... |
class TestStacking2(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='stacking2')
self.env = CausalWorld(task=self.task, enable_visualization=False)
return
def tearDown(self):
self.env.close()
return
def test_determinism(self):
... |
class TestTowers(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='towers')
self.env = CausalWorld(task=self.task, enable_visualization=False)
return
def tearDown(self):
self.env.close()
return
def test_determinism(self):
o... |
def apply_delta_action():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, enable_visualization=True, action_mode='joint_positions', normalize_actions=True, normalize_observations=True, skip_frame=1)
env = DeltaActionEnvWrapper(env)
for _ in range(50):
obs = env.... |
def smooth_action():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, enable_visualization=True, action_mode='joint_positions', normalize_actions=True, normalize_observations=True, skip_frame=1)
env = MovingAverageActionEnvWrapper(env)
for _ in range(50):
obs = e... |
def example():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True)
env = ObjectSelectorWrapper(env)
for _ in range(50):
obs = env.reset()
for i in range(70):
(obs, reward, done, info) = env.step([0, 1, 0])
for i ... |
def example():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task, skip_frame=10, enable_visualization=True)
env = CurriculumWrapper(env, intervention_actors=[GoalInterventionActorPolicy()], actives=[(0, 1000000000, 1, 0)])
for reset_idx in range(30):
obs = env.reset()
... |
def example():
task = generate_task(task_generator_id='pick_and_place')
env = CausalWorld(task, skip_frame=10, enable_visualization=True)
env = CurriculumWrapper(env, intervention_actors=[GoalInterventionActorPolicy()], actives=[(0, 1000000000, 1, 0)])
for reset_idx in range(30):
obs = env.res... |
def example():
task_gen = generate_task(task_generator_id='pushing')
env = CausalWorld(task_gen, skip_frame=10, enable_visualization=True)
env = CurriculumWrapper(env, intervention_actors=[GoalInterventionActorPolicy(), VisualInterventionActorPolicy(), RandomInterventionActorPolicy(), GoalInterventionActo... |
class MyOwnTask(BaseTask):
def __init__(self, **kwargs):
super().__init__(task_name='new_task', variables_space='space_a_b', fractional_reward_weight=1, dense_reward_weights=np.array([]))
self._task_robot_observation_keys = ['time_left_for_task', 'joint_positions', 'joint_velocities', 'end_effect... |
def example():
task = MyOwnTask()
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
for _ in range(2000):
for _ in range(10):
(obs, reward, done, info) = env.step(env.action_space.sample())
random_intervention_dict = env.do_single_random_intervention()
... |
def evaluate_controller():
task_params = dict()
task_params['task_generator_id'] = 'pushing'
world_params = dict()
world_params['skip_frame'] = 3
evaluator = EvaluationPipeline(evaluation_protocols=[protocols.FullyRandomProtocol(name='P10', variable_space='space_a')], task_params=task_params, worl... |
def control_policy(env):
def _control_policy(obs):
return env.get_robot().get_joint_positions_from_tip_positions(obs[(- 9):], obs[1:10])
return _control_policy
|
def evaluate_controller():
task_params = dict()
task_params['task_generator_id'] = 'reaching'
world_params = dict()
world_params['normalize_observations'] = False
world_params['normalize_actions'] = False
evaluator = EvaluationPipeline(evaluation_protocols=[protocols.ProtocolGenerator(name='go... |
def _make_env(rank):
def _init():
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=False, seed=rank, skip_frame=3)
return env
set_global_seeds(0)
return _init
|
def train_policy():
ppo_config = {'gamma': 0.9988, 'n_steps': 200, 'ent_coef': 0, 'learning_rate': 0.001, 'vf_coef': 0.99, 'max_grad_norm': 0.1, 'lam': 0.95, 'nminibatches': 5, 'noptepochs': 100, 'cliprange': 0.2, 'tensorboard_log': log_relative_path}
os.makedirs(log_relative_path)
policy_kwargs = dict(ac... |
def evaluate_trained_policy():
model = PPO2.load(os.path.join(log_relative_path, 'model.zip'))
def policy_fn(obs):
return model.predict(obs)[0]
evaluator = EvaluationPipeline(evaluation_protocols=[protocols.FullyRandomProtocol(name='P11', variable_space='space_b')], visualize_evaluation=True, tra... |
def compare_controllers():
task_params = dict()
task_params['task_generator_id'] = 'pushing'
world_params = dict()
world_params['skip_frame'] = 3
evaluation_protocols = PUSHING_BENCHMARK['evaluation_protocols']
evaluator_1 = EvaluationPipeline(evaluation_protocols=evaluation_protocols, task_pa... |
def _make_env(rank):
def _init():
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=False, seed=rank)
return env
set_global_seeds(0)
return _init
|
def train_policy():
ppo_config = {'gamma': 0.9988, 'n_steps': 200, 'ent_coef': 0, 'learning_rate': 0.001, 'vf_coef': 0.99, 'max_grad_norm': 0.1, 'lam': 0.95, 'nminibatches': 5, 'noptepochs': 100, 'cliprange': 0.2, 'tensorboard_log': log_relative_path}
os.makedirs(log_relative_path)
policy_kwargs = dict(ac... |
def evaluate_model():
model = PPO2.load(os.path.join(log_relative_path, 'model.zip'))
def policy_fn(obs):
return model.predict(obs)[0]
evaluation_protocols = PUSHING_BENCHMARK['evaluation_protocols']
evaluator = EvaluationPipeline(evaluation_protocols=evaluation_protocols, tracker_path=log_re... |
def _make_env(rank):
def _init():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, enable_visualization=False, seed=rank)
return env
set_global_seeds(0)
return _init
|
def train_policy():
ppo_config = {'gamma': 0.9988, 'n_steps': 200, 'ent_coef': 0, 'learning_rate': 0.001, 'vf_coef': 0.99, 'max_grad_norm': 0.1, 'lam': 0.95, 'nminibatches': 5, 'noptepochs': 100, 'cliprange': 0.2, 'tensorboard_log': log_relative_path}
os.makedirs(log_relative_path)
policy_kwargs = dict(ac... |
def evaluate_model():
model = PPO2.load(os.path.join(log_relative_path, 'model.zip'))
def policy_fn(obs):
return model.predict(obs)[0]
evaluation_protocols = REACHING_BENCHMARK['evaluation_protocols']
evaluator = EvaluationPipeline(evaluation_protocols=evaluation_protocols, tracker_path=log_r... |
def example():
task = generate_task(task_generator_id='creative_stacked_blocks')
env = CausalWorld(task=task, enable_visualization=True)
for _ in range(1):
env.reset()
for _ in range(10):
(obs, reward, done, info) = env.step(env.action_space.sample())
print(env.get_current_... |
def example():
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
counter = 0
for _ in range(1):
for i in range(210):
(obs, reward, done, info) = env.step(env.action_space.low)
if (((i % 50) == 0) an... |
def example():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True)
env.set_starting_state({'goal_block': {'cartesian_position': [0.1, 0.1, 0.1]}})
for _ in range(500):
(obs, reward, done, info) = env.step(env.action_space.sample())
env.... |
def privileged_information():
task = generate_task(task_generator_id='general')
env = CausalWorld(task=task, enable_visualization=True)
env.expose_potential_partial_solution()
env.reset()
for _ in range(10):
goal_intervention_dict = env.sample_new_goal()
(success_signal, obs) = env... |
def example():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
for _ in range(50):
(random_intervention_dict, success_signal, obs) = env.do_single_random_intervention()
print('The random intervention performed is ', ... |
def example():
task = generate_task(task_generator_id='pick_and_place')
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
intervention_space = env.get_variable_space_used()
for _ in range(100):
for i in range(200):
(obs, reward, done, info) = env.step(env.acti... |
def goal_interventions():
task = generate_task(task_generator_id='stacked_blocks')
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
for _ in range(10):
for i in range(200):
(obs, reward, done, info) = env.step(env.action_space.sample())
goal_intervention_... |
def without_intervention_split():
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=True)
env.reset()
for _ in range(2):
for i in range(200):
(obs, reward, done, info) = env.step(env.action_space.sample())
(success_signal, o... |
def with_intervention_split_1():
task = generate_task(task_generator_id='pushing', variables_space='space_a')
env = CausalWorld(task=task, enable_visualization=False)
env.reset()
for _ in range(2):
for i in range(200):
(obs, reward, done, info) = env.step(env.action_space.sample())... |
def with_intervention_split_2():
task = generate_task(task_generator_id='pushing', variables_space='space_b')
env = CausalWorld(task=task, enable_visualization=False)
interventions_space = task.get_intervention_space_a()
env.reset()
for _ in range(2):
for i in range(200):
(obs,... |
def example():
data_recorder = DataRecorder(output_directory='pushing_episodes', rec_dumb_frequency=11)
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=True, data_recorder=data_recorder)
for _ in range(23):
env.reset()
for _ in range(... |
def _make_env():
def _init():
task = generate_task(task_generator_id='picking', joint_positions=[(- 0.21737874), 0.55613149, (- 1.09308519), (- 0.12868997), 0.52551013, (- 1.08006493), (- 0.00221536), 0.46163487, (- 1.00948735)], tool_block_position=[0.0, 0, 0.035], fractional_reward_weight=1, dense_rewa... |
def run_mpc():
task = generate_task(task_generator_id='picking', joint_positions=[(- 0.21737874), 0.55613149, (- 1.09308519), (- 0.12868997), 0.52551013, (- 1.08006493), (- 0.00221536), 0.46163487, (- 1.00948735)], tool_block_position=[0.0, 0, 0.035], fractional_reward_weight=1, dense_reward_weights=np.array([0, ... |
def privileged_information():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, enable_visualization=True, normalize_actions=False)
env.expose_potential_partial_solution()
env.reset()
for _ in range(10):
goal_intervention_dict = env.sample_new_goal()
(... |
def privileged_information():
task = generate_task(task_generator_id='pushing')
env = CausalWorld(task=task, enable_visualization=True)
env.expose_potential_partial_solution()
env.reset()
for _ in range(10):
goal_intervention_dict = env.sample_new_goal()
(success_signal, obs) = env... |
def example():
task = generate_task(task_generator_id='creative_stacked_blocks')
env = CausalWorld(task=task, enable_visualization=True)
for _ in range(20):
env.reset()
for _ in range(200):
(obs, reward, done, info) = env.step(env.action_space.sample())
env.close()
|
def control_policy(env, obs):
return env.get_robot().get_joint_positions_from_tip_positions(obs[(- 9):], obs[1:10])
|
def end_effector_pos():
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, enable_visualization=True, action_mode='joint_positions', normalize_actions=False, normalize_observations=False)
obs = env.reset()
for _ in range(100):
goal_dict = env.sample_new_goal()
... |
def example():
task = generate_task(task_generator_id='stacked_blocks')
env = CausalWorld(task=task, skip_frame=10, enable_visualization=True, seed=0, action_mode='joint_positions', observation_mode='pixel', camera_indicies=[0, 1, 2])
env.reset()
for _ in range(5):
(obs, reward, done, info) = ... |
def experiment(variant):
task = generate_task(task_generator_id='picking', dense_reward_weights=np.array([250, 0, 125, 0, 750, 0, 0, 0.005]), fractional_reward_weight=1, goal_height=0.15, tool_block_mass=0.02)
eval_env = CausalWorld(task=task, skip_frame=3, enable_visualization=False, seed=0, max_episode_leng... |
def simulate_policy():
file = './her-sac-fetch-experiment/her-sac-fetch-experiment_2020_07_07_11_11_14_0000--s-0/params.pkl'
data = torch.load(file)
policy = data['evaluation/policy']
policy.reset()
def policy_func(obs):
(a, agent_info) = policy.get_action(obs)
return a
task =... |
def _make_env(rank):
task = generate_task(task_generator_id='reaching')
env = CausalWorld(task=task, skip_frame=10, enable_visualization=False, seed=(0 + rank), max_episode_length=600)
env = GymEnvWrapper(env)
return env
|
def build_and_train():
affinity = dict(cuda_idx=None, workers_cpus=list(range(15)))
sampler = CpuSampler(EnvCls=_make_env, env_kwargs=dict(rank=0), batch_T=6000, batch_B=20)
algo = SAC(bootstrap_timelimit=False)
agent = SacAgent()
runner = MinibatchRl(algo=algo, agent=agent, sampler=sampler, n_ste... |
def _make_env(rank):
task = generate_task(task_generator_id='picking', dense_reward_weights=np.array([250, 0, 125, 0, 750, 0, 0, 0.005]), fractional_reward_weight=1, goal_height=0.15, tool_block_mass=0.02)
env = CausalWorld(task=task, skip_frame=3, enable_visualization=False, seed=0, max_episode_length=600)
... |
def build_and_train():
opt_affinities = list()
opt_affinity = dict(cpus=[0], cuda_idx=None, torch_threads=1, set_affinity=True)
opt_affinities.append(opt_affinity)
smp_affinity = AttrDict(all_cpus=[0, 1], master_cpus=[0], workers_cpus=[1], master_torch_threads=1, worker_torch_threads=1, cuda_idx=None,... |
def simulate_policy():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True, skip_frame=3, seed=0, max_episode_length=600)
env = GymEnvWrapper(env)
file = './itr_1097499.pkl'
data = torch.load(file)
agent_state_dict = data['agent_state_dict']... |
def example():
task = generate_task(task_generator_id='creative_stacked_blocks')
env = CausalWorld(task=task, enable_visualization=False, seed=0)
actions = [env.action_space.sample() for _ in range(200)]
env.reset()
observations_1 = []
rewards_1 = []
for i in range(200):
(observati... |
def example():
task_gen = generate_task(task_generator_id='pushing')
env = CausalWorld(task_gen, skip_frame=1, enable_visualization=True)
env = DeltaActionEnvWrapper(env)
env = CurriculumWrapper(env, intervention_actors=[VisualInterventionActorPolicy()], actives=[(0, 20, 1, 0)])
for reset_idx in r... |
def example():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True)
env.set_starting_state({'goal_block': {'cartesian_position': [0.1, 0.1, 0.1]}})
for _ in range(500):
(obs, reward, done, info) = env.step(env.action_space.sample())
env.... |
def train_policy(num_of_envs, log_relative_path, maximum_episode_length, skip_frame, seed_num, ppo_config, total_time_steps, validate_every_timesteps, task_name):
def _make_env(rank):
def _init():
task = generate_task(task_generator_id=task_name)
env = CausalWorld(task=task, skip... |
def save_config_file(ppo_config, env, file_path):
task_config = env._task.get_task_params()
for task_param in task_config:
if (not isinstance(task_config[task_param], str)):
task_config[task_param] = str(task_config[task_param])
env_config = env.get_world_params()
env.close()
c... |
def simulate_policy():
task = generate_task(task_generator_id='picking')
env = CausalWorld(task=task, enable_visualization=True, skip_frame=3, seed=0, max_episode_length=600)
file = './model_600000_steps.zip'
model = SAC.load(file)
def policy_func(obs):
return model.predict(obs, determini... |
def train_policy(num_of_envs, log_relative_path, maximum_episode_length, skip_frame, seed_num, sac_config, total_time_steps, validate_every_timesteps, task_name):
def _make_env(rank):
def _init():
task = generate_task(task_generator_id=task_name)
env = CausalWorld(task=task, skip... |
def save_config_file(sac_config, env, file_path):
task_config = env.get_task().get_task_params()
for task_param in task_config:
if (not isinstance(task_config[task_param], str)):
task_config[task_param] = str(task_config[task_param])
env_config = env.get_world_params()
env.close()
... |
def example():
task = generate_task(task_generator_id='pick_and_place')
env = CausalWorld(task=task, skip_frame=3, enable_visualization=True)
policy = PickAndPlaceActorPolicy()
env.close()
|
def example():
task = generate_task(task_generator_id='stacking2', tool_block_mass=0.02)
env = CausalWorld(task=task, enable_visualization=True, action_mode='end_effector_positions')
policy = GraspingPolicy(tool_blocks_order=[0, 1])
for _ in range(20):
policy.reset()
obs = env.reset()
... |
def example():
task = generate_task(task_generator_id='pick_and_place')
world_params = dict()
world_params['skip_frame'] = 3
world_params['seed'] = 0
stable_baselines_policy_path = './model_100000000_steps.zip'
model = PPO2.load(stable_baselines_policy_path)
def policy_fn(obs):
re... |
def example():
task = generate_task(task_generator_id='picking')
world_params = dict()
world_params['skip_frame'] = 3
world_params['seed'] = 0
stable_baselines_policy_path = './model_2000000_steps.zip'
model = SAC.load(stable_baselines_policy_path)
def policy_fn(obs):
return model... |
def example():
task = generate_task(task_generator_id='reaching')
world_params = dict()
world_params['skip_frame'] = 1
world_params['seed'] = 0
agent = ReacherActorPolicy()
def policy_fn(obs):
return agent.act(obs)
viewer.view_policy(task=task, world_params=world_params, policy_fn... |
def example():
task = generate_task(task_generator_id='picking')
world_params = dict()
world_params['skip_frame'] = 3
world_params['seed'] = 200
viewer.record_video_of_random_policy(task=task, world_params=world_params, file_name='picking_video', number_of_resets=1, max_time_steps=300)
|
def example():
data = DataLoader(episode_directory='pushing_episodes')
episode = data.get_episode(6)
viewer.record_video_of_episode(episode=episode, file_name='pushing_video')
viewer.view_episode(episode)
|
def get_wordmap(textfile):
words = {}
We = []
f = io.open(textfile, 'r', encoding='utf-8')
lines = f.readlines()
if (len(lines[0].split()) == 2):
lines.pop(0)
ct = 0
for (n, i) in enumerate(lines):
word = i.split(' ', 1)[0]
vec = i.split(' ', 1)[1].split(' ')
... |
def get_minibatches_idx(n, minibatch_size, shuffle=False):
idx_list = np.arange(n, dtype='int32')
if shuffle:
np.random.shuffle(idx_list)
minibatches = []
minibatch_start = 0
for i in range((n // minibatch_size)):
minibatches.append(idx_list[minibatch_start:(minibatch_start + minib... |
def max_pool(x, lengths, gpu):
out = torch.FloatTensor(x.size(0), x.size(2)).zero_()
if (gpu >= 0):
out = out.cuda()
for i in range(len(lengths)):
out[i] = torch.max(x[i][0:lengths[i]], 0)[0]
return out
|
def mean_pool(x, lengths, gpu):
out = torch.FloatTensor(x.size(0), x.size(2)).zero_()
if (gpu >= 0):
out = out.cuda()
for i in range(len(lengths)):
out[i] = torch.mean(x[i][0:lengths[i]], 0)
return out
|
def lookup(words, w):
w = w.lower()
if (w in words):
return words[w]
|
class Example(object):
def __init__(self, sentence):
self.sentence = sentence.strip().lower()
self.embeddings = []
self.representation = None
def populate_embeddings(self, words):
sentence = self.sentence.lower()
arr = sentence.split()
for i in arr:
... |
class SimilarityEvaluator():
def __init__(self, model_path='models/sim/sim.pt', tokenizer_path='models/sim/sim.sp.30k.model', gpu=False):
self.model_path = model_path
self.tokenizer_path = tokenizer_path
self.tok = TreebankWordTokenizer()
kw = {}
if (not torch.cuda.is_avai... |
def make_example(sentence, model):
sentence = sentence.lower()
sentence = ' '.join(tok.tokenize(sentence))
sentence = sp.EncodeAsPieces(sentence)
wp1 = Example(' '.join(sentence))
wp1.populate_embeddings(model.vocab)
return wp1
|
def find_similarity(s1, s2):
with torch.no_grad():
s1 = [make_example(x, model) for x in s1]
s2 = [make_example(x, model) for x in s2]
(wx1, wl1, wm1) = model.torchify_batch(s1)
(wx2, wl2, wm2) = model.torchify_batch(s2)
scores = model.scoring_function(wx1, wm1, wl1, wx2, w... |
def cosine(v1, v2):
return (np.dot(v1, v2) / np.sqrt(((sum((v1 ** 2)) * sum((v2 ** 2))) + 1e-10)))
|
class EmbeddingSimilarityChooser():
def __init__(self, sim_coef=100, tokenizer=None):
self.glove_embedding = WordEmbeddings('glove')
self.sim_coef = sim_coef
self.tokenizer = tokenizer
def embed(self, text):
toks = self.glove_embedding.embed(Sentence(text))[0]
if (not... |
class NgramSalienceCalculator():
def __init__(self, tox_corpus, norm_corpus, use_ngrams=False):
ngrams = ((1, 3) if use_ngrams else (1, 1))
self.vectorizer = CountVectorizer(ngram_range=ngrams)
tox_count_matrix = self.vectorizer.fit_transform(tox_corpus)
self.tox_vocab = self.vect... |
def adjust_logits(logits, label=0):
return (logits - ((token_toxicities * 100) * (1 - (2 * label))))
|
def add_sys_path(p):
p = os.path.abspath(p)
print(p)
if (p not in sys.path):
sys.path.append(p)
|
def adjust_logits(logits, label):
return (logits - (editor.token_toxicities * 3))
|
def bpe_tokenize(bpe_tokenizer, sentence):
sent_bpe_tokens = []
sent_bpe_offsets = []
for token in sentence:
token_bpes = bpe_tokenizer.tokenize(token.text)
sent_bpe_offsets += [(token.begin, token.end) for _ in range(len(token_bpes))]
sent_bpe_tokens += token_bpes
return (sent... |
def nlargest_indexes(arr, n_top):
arr_ids = np.argpartition(arr, (- n_top))[(- n_top):]
sel_arr = arr[arr_ids]
top_ids = arr_ids[np.argsort((- sel_arr))]
return top_ids
|
def remove_masked_token_subwords(masked_position, bpe_tokens, bpe_offsets):
'\n If the masked token has been tokenied into multiple subwords: like dieting-->diet and ##ing\n keep the first subword and remove others.\n '
logger.debug(f'bpe tokens: {bpe_tokens}')
logger.debug(f'bpe offsets: {bpe_of... |
def merge_sorted_results(objects_left, scores_left, objects_right, scores_right, max_elems):
result_objects = []
result_scores = []
j = 0
i = 0
while True:
if (len(result_scores) == max_elems):
break
if (i == len(scores_left)):
result_objects += objects_righ... |
class MaskedTokenPredictorBert():
def __init__(self, model, bpe_tokenizer, max_len=250, mask_in_multiunit=False, device=None, label=0, logits_postprocessor=None, contrast_penalty=0, mean=np.mean, confuse_bert_args=False):
self._model = model
self._bpe_tokenizer = bpe_tokenizer
self._max_l... |
def find_bpe_position_by_offset(bpe_offsets, target_offset):
bpe_nums = []
for (sent_num, sent) in enumerate(bpe_offsets):
if (sent[(- 1)][0] < target_offset[0]):
continue
for (bpe_num, bpe) in enumerate(sent):
if ((target_offset[0] <= bpe[0]) and (bpe[1] <= target_offs... |
def generate_seq_indexes(indexes):
if (not indexes):
(yield [])
return
for ind in indexes[0]:
for seq in generate_seq_indexes(indexes[1:]):
(yield ([ind] + seq))
|
class PairsDataset(torch.utils.data.Dataset):
def __init__(self, x, y):
self.x = x
self.y = y
def __getitem__(self, idx):
assert (idx < len(self.x['input_ids']))
item = {key: val[idx] for (key, val) in self.x.items()}
item['decoder_attention_mask'] = self.y['attention... |
class TrAr(TrainingArguments):
@cached_property
def _setup_devices(self):
return device
|
class DataCollatorWithPadding():
def __init__(self, tokenizer):
self.tokenizer = tokenizer
def __call__(self, features: List[Dict[(str, Union[(List[int], torch.Tensor)])]]) -> Dict[(str, torch.Tensor)]:
batch = self.tokenizer.pad(features, padding=True)
ybatch = self.tokenizer.pad({'... |
def detokenize(text):
text = text.replace(' .', '.').replace(' ,', ',').replace(' !', '!')
text = text.replace(' ?', '?').replace(' )', ')').replace('( ', '(')
return text
|
def drop_bad_words(text, max_len=30, return_digits=None):
parts = re.split('(\\W)', text)
if max_len:
parts = [w for w in parts if (len(w) <= max_len)]
if (return_digits is not None):
parts = [(str(return_digits) if (p == 'DIGIT') else p) for p in parts]
return ''.join(parts)
|
def text_preprocess(text):
text = text.lstrip(punkt)
text = detokenize(text)
text = drop_bad_words(text)
return text
|
def text_postprocess(text):
res2 = text.rstrip(punkt)
if (len(res2) < len(text)):
res2 += text[len(res2)]
return res2
|
class DType(IntEnum):
'データ型定義\n '
BIT = (0 + 1)
BINARY = (0 + 2)
FP16 = (256 + 16)
FP32 = (256 + 32)
FP64 = (256 + 64)
INT8 = (512 + 8)
INT16 = (512 + 16)
INT32 = (512 + 32)
INT64 = (512 + 64)
UINT8 = (768 + 8)
UINT16 = (768 + 16)
UINT32 = (768 + 32)
UINT64 =... |
class Border(IntEnum):
CONSTANT = 0
REFLECT = 1
REFLECT_101 = 2
REPLICATE = 3
WRAP = 4
|
def dtype_numpy_to_bb(dtype):
if (dtype == np.float32):
return core.TYPE_FP32
elif (dtype == np.float64):
return core.TYPE_FP64
elif (dtype == np.int8):
return core.TYPE_INT8
elif (dtype == np.int16):
return core.TYPE_INT16
elif (dtype == np.int32):
return c... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.