def generate_disk(self):
GCdist = coord.Galactocentric.galcen_distance.value * 1000.
h = self.h
H = self.H
rho0 = self.rho0
theta = np.random.uniform(np.pi, 2 * np.pi, N)
# the r component
rho_r = lambda r: np.exp(-r / H) / np.exp(-8300. / H
) # normalised density
pdf_r = lambda r: 2 * np.pi * r * rho_r(r) # cylindrical coordiantes
cdf_r = lambda l: integrate.quad(pdf_r, 0., l)
rgrid = np.hstack(([0], np.logspace(0, 7, 10000)))
totr = cdf_r(np.inf)[0]
icdf_r = lambda n: np.interp(n, [cdf_r(_r)[0] / totr
for _r in rgrid], rgrid)
# the z compoment
rho_z = lambda z: np.exp(-z / h) / np.exp(-27. / h
) # normalised density
cdf_z = lambda l: integrate.quad(rho_z, 0, l) # cdf
rgrid = np.hstack(([0], np.logspace(-2, 5, 10000)))
totz = cdf_z(np.inf)[0]
icdf_z = lambda n: np.interp(n, [cdf_z(_r)[0] / totz
for _r in rgrid], rgrid)
# total number of points in disk
N = rho0 * cdf_r(np.inf) * 2 * cdf_z(
np.inf) # factor 2 is from z and -z
r = icdf_r[np.uniform(N)] # make r
z = icdf_z[np.uniform(N)] # make z
z *= (-1)**np.random.randint(0, 2,
N) # give z positive and negative values
# make x,y
x = r * np.sin(theta)
y = r * np.cos(theta)
# density around the sun:
self.c = SkyCoord(x=x * u.pc,
y=y * u.pc,
z=z * u.pc,
frame='galactocentric')
self.scale = scale
self.eq = self.c.transform_to(coord.ICRS)
self.gc = self.c.transform_to(coord.Galactic)
def generate_circleDuration(period, i, decay=0, radius=1, x0=0, y0=0):
R = radius
x_0 = x0
y_0 = y0
d = np.uniform(0.01, 0.1)
# for t in range(0, 2 * pi, 0.01):
dd = list()
zz = list()
for t in range(1000):
t = t / 1000.0
x = (R * np.cos(2 * pi * t / period) + R) / 2 * R + x_0
y = (R * np.sin(2 * pi * t / period) + R) / 2 * R + y_0
dd.append(y)
zz.append(x)
miy = min(dd)
mix = min(zz)
may = max(dd)
max = max(zz)
if i > period:
return [-1, -1]
x = (R * np.cos(2 * pi * i / period) + R) / 2 * R + x_0
y = (R * np.sin(2 * pi * i / period) + R) / 2 * R + y_0
return [x, y]
def generate_Heart(period, i, decay):
x_0 = np.randint(0, 1)
y_0 = np.randint(0, 1)
d = np.uniform(0.01, 0.1)
t = i
dd = list()
zz = list()
for t in range(1000):
t = t / 1000.0
t = 2 * pi * t / period
x = 16 * pow(np.sin(t), 3)
y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(
4 * t)
dd.append(y)
zz.append(x)
miy = min(dd)
mix = min(zz)
may = max(dd)
maxx = max(zz)
i = 2 * pi * i / period
x = 16 * pow(np.sin(i), 3)
y = 13 * np.cos(i) - 5 * np.cos(2 * i) - 2 * np.cos(3 * i) - np.cos(4 * i)
x = (x - mix) / (maxx - mix)
y = (y - miy) / (may - miy)
return [x, y]
def queries_answers_weights_sol():
import opt
import cenquery
import opt.cvx as cvx
shape=(6,4,5)
q2_subset = (slice(3,5), slice(2,4), slice(0,2))
q2_answer_shape = (2,2)
prng = numpy.random.RandomState(seed)
seed=23
q1 = cenquery.Query(shape)
q2 = cenquery.Query(shape, subset=q2_subset, add_over_margins=(0,))
queries = [q1, q2]
ans1 = numpy.uniform(low=-0.5, high=0.5, size=shape)
ans2 = numpy.uniform(low=-0.5, high=0.5, size=q2_answer_shape)
answers = [ans1, ans2]
weights = [1.0, 2.0]
solution = None
return (queries, answers, weights, solution)
def generate_examplesX(length, n_patterns, output):
X, y = list(), list()
for _ in range(n_patterns):
p = np.randint(10, 20)
d = np.uniform(0.01, 0.1)
sequence = [0, 1] # generate_sequenceDampedSin(length + output, p, d)
X.append(sequence[:-output])
y.append(sequence[-output:])
X = np.array(X).reshape(n_patterns, length, 1)
y = np.array(y).reshape(n_patterns, output)
return X, y
def mcerror(lmbda,nflux,wavelength1,wavelength2,m,c,rmse):
trials = 3000
guess = []
ewindex = np.where((lmbda >= wavelength1) & (lmbda <= wavelength2))
dlmbda = lmbda[2]-lmbda[1]
for i in range(trials):
fitline = m * lmbda + c + np.uniform(-1,1) * rmse
fx = np.sum(1-nflux[ewindex]) * dlmbda
guess.append(fx)
return np.mean(guess), np.std(guess)
def run_kwargs(self):
kwargs = dict(exe="../fast/fast",
persist_hits=False,
noise_if_no_signal=True)
# Dice number of particles
n = np.random.random_integers(self.n_min, self.n_max, self.step)
if self.log:
n = np.array(np.ceil(
np.exp(
np.uniform(np.log(self.n_min), np.log(self.n_max),
self.step))),
dtype="int")
return [clone(kwargs, n_particles=ni) for ni in n]
def generate_circle(period, i, decay=0, radius=1, x0=0, y0=0):
R = radius
x_0 = x0
y_0 = y0
d = np.uniform(0.01, 0.1)
# for t in range(0, 2 * pi, 0.01):
dd = list()
zz = list()
for t in range(1000):
t = t / 1000.0
x = (R * np.cos(2 * pi * t / period) + R) / 2 * R + x_0
y = (R * np.sin(2 * pi * t / period) + R) / 2 * R + y_0
dd.append(y)
zz.append(x)
x = (R * np.cos(2 * pi * i / period) + R) / 2 * R + x_0
y = (R * np.sin(2 * pi * i / period) + R) / 2 * R + y_0
return [x, y]
def findnextorbit(
m_star, m_planet, disk_edge,
iceline): #Note disk_edge is orbit of planet before in ordinal number
m_star = m_star #solar masses
m_star_kg = np.multiply(m_star, 1.989e30)
m_planet = m_planet # earth masses, preferable the isolation mass
m_planet_kg = np.multiply(m_planet, 5.972e24)
disk_edge = disk_edge # in au
rn.seed(rn.random())
Klist = np.uniform(10, 15, 100).tolist()
factor = np.power(np.divide(m_planet_kg, 3. * m_star_kg), 1. / 3.)
d = disk_edge
c = rn.choice(Klist) * d * factor
b = d + c
return b
def run_kwargs(self):
e = 4.135667516e-15 * 299792458.0 / (self.wavelength * 1e-9)
kwargs = dict(exe="../fast/fast",
persist_hits=False,
noise_if_no_signal=True,
t_input="../sample/resources/led-waveform-12ns.txt",
persist_t_min=0,
persist_t_max=250,
e_min=e,
e_max=e,
simulate_shuntresistor=True,
shuntresistor_recovery_time=30.0)
# Dice number of particles
n = np.random.random_integers(self.n_min, self.n_max, self.step)
if self.log:
n = np.array(np.ceil(
np.exp(
np.uniform(np.log(self.n_min), np.log(self.n_max),
self.step))),
dtype="int")
return [clone(kwargs, n_particles=ni) for ni in n]
for i in xrange(20):
all_lifters.append(common_model((10, )))
for _ in xrange(EPOCHS):
az_ang = random.uniform(-np.pi, np.pi)
ev_ang = random.uniform(-np.pi / 9, np.pi / 9)
rot_ang = random.uniform(0, 2 * np.pi)
x = np.cos(ev_ang) * np.cos(az_ang)
y = np.cos(ev_ang) * np.sin(az_ang)
z = np.sin(ev_ang)
C = np.array([[0, -z, y], [z, 0, -x], [-y, x, 0]])
R = np.identity(
3) + np.sin(rot_ang) * C + (1 - np.cos(rot_ang)) * np.matmul(C, C)
T = np.uniform(0, 1)
for model in all_lifters:
for naam in files:
for i in xrange(20):
X = files[naam][2 * i:2 * i + 2]
X.extend(files[naam][-8:])
X.extend([0., 0., 0.])
z = all_lifters[i].predict(X)
x_ = X[0] * z
y_ = X[1] * z
z_ = z
x_new, y_new, z_new = np.matmul(R, [[x_], [y_], [z_]])
x_new, y_new, z_new = x_new[0], y_new[0], z_new[0]
def concatenateStimuli(MatrixDir, OutDir, Length, n):
# Get matrix wav file paths
wavFiles = globDir(MatrixDir, '*.wav')
stim_parts = os.path.join(MatrixDir, "stim_parts.csv")
stim_words = os.path.join(MatrixDir, "stim_words.csv")
stim_part_rows = []
with open(stim_parts, 'r') as csvfile:
stim_part_rows = [line for line in csv.reader(csvfile)]
with open(stim_words, 'r') as csvfile:
stim_word_rows = [line for line in csv.reader(csvfile)]
wavFiles = natsorted(wavFiles)
totalSize = 0
y = []
parts = []
questions = []
i = 0
gapSize = np.uniform(0.8, 1.2, len(wavFiles))
for wav, gap in zip(wavFiles, gapSize):
if i == n:
break
wavObj = PySndfile(wav)
fs = wavObj.samplerate()
size = wavObj.frames()
totalSize += size
totalSize += int(gap * fs)
if (totalSize / fs) > Length:
# total size + 2 second silence at start
y.append(np.zeros((totalSize + 2 * fs, 3)))
parts.append([])
questions.append([])
i += 1
totalSize = 0
writePtr = 2 * fs
idx = np.arange(0, writePtr)
chunk = np.zeros(idx.size)
chunk = np.vstack([chunk, chunk, chunk]).T
trigger = gen_trigger(idx, 2., 0.01, fs)
chunk[:, 2] = trigger
for i, _ in enumerate(y):
y[i][0:writePtr, :] = chunk
i = 0
for wav, word, part in zip(wavFiles, stim_word_rows, stim_part_rows):
if writePtr >= y[i].shape[0]:
i += 1
writePtr = fs * 2
if i == n:
break
x, fs, encStr, fmtStr = sndio.read(wav, return_format=True)
threeMs = int(0.1 * fs)
silence = np.zeros(threeMs)
chunk = np.append(x, silence)
idx = np.arange(writePtr, writePtr + chunk.shape[0])
chunk = np.vstack([chunk, chunk, np.zeros(chunk.shape[0])]).T
trigger = gen_trigger(idx, 2., 0.01, fs)
chunk[:, 2] = trigger
y[i][writePtr:writePtr + chunk.shape[0], :] = chunk
questions[i].append(word)
parts[i].append(part)
writePtr += chunk.shape[0]
for ind, (data, q, p) in enumerate(zip(y, questions, parts)):
pysndfile.sndio.write(os.path.join(OutDir, 'stim_{}.wav'.format(ind)),
data,
format=fmtStr,
enc=encStr)
with open('./out/stim/stim_words_{}.csv'.format(ind), 'w') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(q)
with open('./out/stim/stim_parts_{}.csv'.format(ind), 'w') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(p)
def select_rand(i):
j = i
while j == i:
j = int(np.uniform(0, self.m))
return j
import pandas as pd
import matplotlib.pyplot as plot
import numpy as np
filePath = ("c://dataTest.csv")
dataFile = pd.read_csv(filePath, header=None, prefix="V")
target = []
for i in range(200):
if dataFile.iat[i, 10] >= 7:
target.append(1.0 + np.uniform(-0.3, 0.3))
else:
target.append(0.0 + np.uniform(-0.3, 0.3))
dataRow = dataFile.iloc[0:200, 10]
plot.scatter(dataRow, target, alpha=0.5, s=100)
plot.xlabel("Attribute")
plot.ylabel("Target")
plot.show()
def random_site( seq_length, model_length ):
return Site(
start = numpy.randint( seq_length - model_length ),
rev_comp = numpy.uniform() > 0.5,
length = model_length
)
def metaEvolution(trainDates, testDate, metaPopulationSize=15, useCrossover=False, useGenerationForcing=False, sendEmails=False, createGraphs=False):
print("RUNNING META EVOLUTION")
#set first generation genomes
metaPopulation = []
prevAvgFit = 0
prevPopulation = []
prevFitnesses = []
prevTopGenome = []
keys = list(metaGenomeDictionary.keys())
for i in range(metaPopulationSize):
currentGenome = {}
for x in range(len(keys)):
if type(metaGenomeDictionary[keys[x]]["start"][0]) == np.float64:
currentGenome[keys[x]] = np.uniform(metaGenomeDictionary[keys[x]]["start"][0], metaGenomeDictionary[keys[x]]["start"][1])
elif metaGenomeDictionary[keys[x]]["clip"][0] == None and metaGenomeDictionary[keys[x]]["clip"][1] == None:
currentGenome[keys[x]] = random.randint(0, 1)
else:
currentGenome[keys[x]] = random.randint(int(metaGenomeDictionary[keys[x]]["start"][0]), int(metaGenomeDictionary[keys[x]]["start"][1]))
metaPopulation.append(currentGenome)
metaGenFitnesses = []
metaGenTestFitnesses = []
for genNum in range(100): #meta generations
metaFitnesses = []
rawMetaFitnesses = []
#get fitnesses for each meta genome by evolving a model with them
for i in range(len(metaPopulation)):
tempMetaFitnesses = []
for x in range(len(trainDates)):
tempMetaFitnesses.append(float(modelEvolution(metaPopulation[i], [trainDates[x]])))
currentMetaFitness = statistics.mean(tempMetaFitnesses)
rawMetaFitnesses.append(currentMetaFitness)
metaFitnesses.append(currentMetaFitness / 200)
print("Gen " + str(genNum + 1) + " Genome " + str(i + 1) +": " + str(round(rawMetaFitnesses[-1], 2)))
topGenome = copy.deepcopy(metaPopulation)[metaFitnesses.index(max(metaFitnesses))]
#report the best fitness
testMetaFitness = modelEvolution(topGenome, [testDate])
printString = "Gen " + str(genNum + 1) + " | Top Fitness: " + str(max(rawMetaFitnesses)) + " | Avg Fitnesses: " + str(sum(rawMetaFitnesses) / len(metaFitnesses)) + " | Test Fitness: " + str(testMetaFitness) + " | Genome: " + str(topGenome)
print(printString)
if createGraphs:
#make graph
metaGenFitnesses.append(statistics.mean(rawMetaFitnesses))
plt.figure(figsize=(10,10))
plt.plot(metaGenFitnesses)
plt.savefig("train.png")
plt.close()
metaGenTestFitnesses.append(testMetaFitness)
plt.figure(figsize=(10,10))
plt.plot(metaGenTestFitnesses)
plt.savefig("test.png")
plt.close()
#make new generation
#generation forcing
if useGenerationForcing:
if(genNum > 1):
if(statistics.mean(rawMetaFitnesses) < prevAvgFit):
#use prev generation
metaPopulation = prevPopulation
metaFitnesses = prevFitnesses
topGenome = prevTopGenome
print("Using Previous Generation")
else:
prevFitnesses = metaFitnesses
prevPopulation = metaPopulation
prevTopGenome = topGenome
prevAvgFit = statistics.mean(rawMetaFitnesses)
print("Using Current Generation")
else:
prevFitnesses = metaFitnesses
prevPopulation = metaPopulation
prevTopGenome = topGenome
prevAvgFit = statistics.mean(rawMetaFitnesses)
newMetaPopulation = [copy.deepcopy(topGenome)]
for i in range(len(metaPopulation) - 1):
if useCrossover:
#crossover last generation
tempPop = copy.deepcopy(metaPopulation)
tempFit = copy.deepcopy(metaFitnesses)
choices = [0,0]
choices[0] = np.random.choice(len(tempPop), 1, p=softmax(copy.deepcopy(tempFit)), replace=True)[0]
tempPop.pop(choices[0])
tempFit.pop(choices[0])
choices[1] = np.random.choice(len(tempPop), 1, p=softmax(copy.deepcopy(tempFit)), replace=True)[0]
newMetaPopulation.append(metaCrossover(copy.deepcopy(metaPopulation)[choices[0]], copy.deepcopy(metaPopulation)[choices[1]], 0.25))
else:
#mutate top genome
newMetaPopulation.append(metaMutation(copy.deepcopy(topGenome), 0.25))
metaPopulation = newMetaPopulation
if sendEmails:
body = """\
Generation {gen2} has finished at {time}. On to the next! Gen Stats: {genstats}""".format(gen1=str(genNum + 1), gen2=str(genNum + 1), time=str(datetime.datetime.now()), genstats = printString)
CommCore.sendEmail(subject="Generation Finished!", body=body)
def _reset_sim(self):
#########################
if self.episode > 0:
self.success_rate = float(
numpy.sum(self.results) / float(len(self.results)))
print("Episode: {} Success Rate: {} ".format(
self.episode, self.success_rate))
if len(self.results) < 10:
self.results.append(0)
else:
self.results.pop(0)
#########################
self.episode += 1
if self.vary == True:
deviation_x = numpy.random.uniform(-self.init_vary_range,
self.init_vary_range)
deviation_q = self.get_dq(deviation_x)
else:
deviation_q = numpy.array([0, 0, 0, 0, 0, 0])
#if self.ft_drift:
# self.ft_drift_val = numpy.random.uniform(-self.ft_drift_range, self.ft_drift_range)
#self.pos_drift_val = numpy.random.uniform(-self.pos_drift_range, self.pos_drift_range)
self.ft_dr_cor_noise = numpy.concatenate([
numpy.random.uniform(-self.f_var_dr_cor, self.f_var_dr_cor, 3),
numpy.random.uniform(-self.t_var_dr_cor, self.t_var_dr_cor, 3)
])
self.pos_dr_cor_noise = numpy.uniform(-self.pos_var_dr_cor,
self.pos_var_dr_cor, 3)
self.rot_dr_cor_noise = numpy.uniform(
-self.rot_var_dr_cor, self.rot_var_dr_cor, 3) * (numpy.pi / 180)
del self.sim
self.offset = randomize.randomize_ur10_xml(worker_id=self.worker_id,
**self.randomize_kwargs)
model = mujoco_py.load_model_from_path(self.model_path)
self.sim = mujoco_py.MjSim(model, nsubsteps=self.n_substeps)
self.goal = self._sample_goal()
if not self.viewer is None:
self._get_viewer('human').update_sim(self.sim)
#self._get_viewer('human')._ncam = self.sim.model.ncam
self.ctrl_buffer = np.repeat(
(self.initial_qpos + deviation_q).reshape(1, 6), 4, axis=0)
self.b, self.a = butter(2, 0.12)
self.zi = [
lfilter_zi(self.b, self.a) *
(self.initial_qpos[i] + deviation_q[i]) for i in range(6)
]
self.qi_diff = 0
self.last_target_q = self.initial_qpos + deviation_q
self.set_state(self.initial_qpos + deviation_q)
self.sim.forward()
self.sim.step()
if self.sim.data.ncon == 0:
for i in range(100):
self.sim.data.ctrl[:] = self.sim.data.qfrc_bias.copy()
self.sim.step()
self.init_x = numpy.concatenate(
(self.sim.data.get_body_xpos("gripper_dummy_heg"),
self.sim.data.get_body_xquat("gripper_dummy_heg")))
self.set_force_for_q(self.initial_qpos + deviation_q)
return self.sim.data.ncon == 0
def reset(self, stdv=None):
if not stdv:
stdv = 1. / np.sqrt(self.weight.shape[2])
self.weight = np.uniform(-stdv, stdv, self.weight.shape)
self.bias = np.uniform(-stdv, stdv, self.weight.shape[0])
def sample_bounded(bounds):
d = len(bounds)
x = np.zeros(shape=(d))
for i in range(d):
x[i] = np.uniform(bounds[i][0], bounds[i][1])
return x
def random_site(seq_length, model_length):
return Site(start=numpy.randint(seq_length - model_length),
rev_comp=numpy.uniform() > 0.5,
length=model_length)
def reset(self, stdv=None):
if not stdv:
stdv = 1./np.sqrt(self.weight.shape[2])
self.weight = np.uniform(-stdv, stdv, self.weight.shape)
self.bias = np.uniform(-stdv, stdv, self.weight.shape[0])
def general_sampling(network, net_cls, dataset, args=None): # pylint: disable=R0914,R0912,R0915
"""Query-by-committee (pool): disagreement between random inits of net."""
# Batch-mode settings
batch_size = int(dataset.online_len() / args.num_batches)
label_batch_size = int(args.sample_prop * batch_size)
labeled_ptrs = np.array([], dtype=np.int32)
# Initialize committee
committee = [network]
if args.sampling_strategy in ["qbc"]:
for i in range(args.vs_size - 1):
this_network = net_cls(args.num_cls).to(args.device)
this_network.train()
train(this_network,
dataset,
epochs=args.initial_epochs,
args=args,
milestones=LONG_MILESTONES)
this_network.eval()
committee.append(this_network)
# Map pointers to label
if args.diversify == "cheat":
ys = []
for i in dataset.indices(split="online"):
y, _ = dataset.train_labels[i]
ys.append(y)
ys = np.array(ys, dtype=np.int32)
# Begin batch-mode sampling
for batch_i in range(1, args.num_batches + 1):
stats = [] # Smaller stats means higher priority
sep_stats = [] # Bigger value means more important
with torch.no_grad():
for image, y, _ in dataset.iterate(
batch_size=args.infer_batch_size,
shuffle=False,
split="online"):
image = image.to(args.device)
# Aggregate domain sep
if args.domainsep:
this_network = committee[0]
this_network.eval()
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
sep_stats.append(np.sum(-p * np.log(p + 1e-9), axis=1))
# Produce stats depending on algorithm
if args.sampling_strategy == "qbc":
predictions = []
for this_network in committee:
this_network.eval()
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
predictions.append(np.argmax(p, axis=1))
predictions = np.stack(predictions)
stats.append(mode(predictions, axis=0).count[0])
if args.sampling_strategy == "bald":
predictions = []
this_network = committee[0]
this_network.train()
with torch.no_grad():
for _ in range(args.bald_size):
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
predictions.append(np.argmax(p, axis=1))
predictions = np.stack(predictions)
stats.append(mode(predictions, axis=0).count[0])
if args.sampling_strategy == "cheat":
this_network = committee[0]
this_network.eval()
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
stats.append(np.equal(np.argmax(p, axis=1), y))
if args.sampling_strategy == "margin":
margin = []
this_network = committee[0]
this_network.eval()
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
sorted_p = np.sort(p)
margin = sorted_p[:, -1] - sorted_p[:, -2]
stats.append(margin)
if args.sampling_strategy == "maxent":
this_network = committee[0]
this_network.eval()
output = torch.exp(this_network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
stats.append(-np.sum(-p * np.log(p + 1e-9), axis=1))
if args.sampling_strategy == "random":
stats.append(np.random.uniform(size=(len(image), )))
if args.diversify in ["guess", "overguess"]:
# Produce new ys
ys = []
network.eval()
for image, _, _ in dataset.iterate(
batch_size=args.infer_batch_size,
shuffle=False,
split="online"):
image = image.to(args.device)
output = torch.exp(network(image))
p = output.cpu().data.numpy()
if not args.train_iw and not args.only_rlls_infer:
p = p * dataset.label_weights
p = p / np.sum(p, axis=1)[:, None]
ys.append(np.argmax(p, axis=1))
ys = np.concatenate(ys)
# Concatenate stats
stats = np.concatenate(stats)
if args.domainsep:
sep_stats = np.concatenate(sep_stats)
sep_stats[sep_stats < 0.5] = 0
sep_odds = np.uniform(size=sep_stats.shape)
selection = np.greater(sep_odds, np.uniform(size=sep_stats.shape))
stats[~selection] = np.infty
# Stack stats
new_ptrs = np.setdiff1d(np.arange(len(stats)), labeled_ptrs)
sorted_ptrs = new_ptrs[np.argsort(stats[new_ptrs])]
if args.diversify == "none":
labeled_ptrs = np.concatenate(
[labeled_ptrs, sorted_ptrs[:label_batch_size]])
elif args.diversify == "guess":
# Take top examples from each label
sorted_ptrs_by_label = {y: [] for y in range(args.num_cls)}
for ptr in sorted_ptrs:
sorted_ptrs_by_label[ys[ptr]].append(ptr)
# Of remaining ptrs per label, find most equal allocation
label_lens = sorted(
[len(x) for x in sorted_ptrs_by_label.values()])
for i, l in enumerate(label_lens):
size = math.ceil((label_batch_size - sum(label_lens[:i])) /
len(label_lens[i:]))
if size <= l:
break
size = -1
if size == -1:
raise ValueError()
# Label pts per each
for k, ptrs in sorted_ptrs_by_label.items():
labeled_ptrs = np.concatenate([labeled_ptrs, ptrs[:size]])
assert len(np.unique(labeled_ptrs)) == len(labeled_ptrs)
elif args.diversify == "overguess":
# Take top examples from each label
sorted_ptrs_by_label = {y: [] for y in range(args.num_cls)}
for ptr in sorted_ptrs:
sorted_ptrs_by_label[ys[ptr]].append(ptr)
# Label pts per each
for k, ptrs in sorted_ptrs_by_label.items():
size = math.ceil(dataset.label_weights[k] /
sum(dataset.label_weights) * label_batch_size)
labeled_ptrs = np.concatenate([labeled_ptrs, ptrs[:size]])
assert len(np.unique(labeled_ptrs)) == len(labeled_ptrs)
dataset.label_ptrs(labeled_ptrs)
# Note sample proportion
print("Sample proportion: ", len(labeled_ptrs) / dataset.online_len())
# Train networks on current batch status
if args.domainsep:
committee[0].train()
sep_train(committee[0],
dataset,
epochs=args.partial_epochs,
lr=args.finetune_lr,
args=args)
committee[0].eval()
for this_network in committee:
this_network.train()
train(this_network,
dataset,
epochs=args.partial_epochs,
lr=args.finetune_lr,
args=args)
this_network.eval()
# Handle reweighting procedure
if args.iterative_iw:
label_shift(committee[0], dataset, args)
yield committee[0]
def make (period, util, deadline = None): return arbitrary (period * util, period, np.uniform(1,2) * period)
