def train_dataloader(self): print("train_dataloader") self.ts = DataTraj(self.nfts, conv(self.dgroup, self.dico, self.Batch._fields), idtraj="aircraft") tsload = TensorDataLoader(self.ts, batch_size=self.hparams.batch_size, shuffle=False, pin_memory=True) print("len(train_dataloader)", len(tsload)) return Infinitecycle(tsload, self.hparams.steps_per_epoch)
def backbone(input_layer): """ Argument: input_layer:a 4-d tensor,[samples,rows,cols,channels] Return: three output """ out_put = common.conv(input_layer, filter_shape=(3, 32)) out_put = common.conv(out_put, filter_shape=(3, 64), padding="valid") for i in range(1): out_put = common.res_block(out_put, num_filter=(32, 64)) out_put = common.conv(out_put, filter_shape=(3, 128), padding="valid") for i in range(2): out_put = common.res_block(out_put, num_filter=(64, 128)) out_put = common.conv(out_put, filter_shape=(3, 256), padding="valid") for i in range(8): out_put = common.res_block(out_put, num_filter=(128, 256)) branch_1 = out_put out_put = common.conv(out_put, filter_shape=(3, 512), padding="valid") for i in range(8): out_put = common.res_block(out_put, num_filter=(256, 512)) branch_2 = out_put out_put = common.conv(out_put, filter_shape=(3, 1024), padding="valid") for i in range(4): out_put = common.res_block(out_put, num_filter=(512, 1024)) return branch_1, branch_2, out_put
def createTestStringMM(a, b, n, bits): A = common.conv(a, n) A_b = binaryString(A, bits) B = common.conv(b, n) B_b = binaryString(B, bits) n_b = binaryString(n, bits) wait_time = waitTime(bits, montgomery_multiplication) m_res = common.mont_result(a, b, n) m_res_b = binaryString(m_res, bits) return ("\tREPORT \"Begin test case for a=%(a)d (A=%(A)d), b=%(b)d (B=%(B)d), N=%(n)d\";\n" "\tREPORT \"Expected output is %(m_res)d, %(m_res_b)s\";\n" "\tA_in <= \"%(A_b)s\";\n" "\tB_in <= \"%(B_b)s\";\n" "\tN_in <= \"%(n_b)s\";\n" "\tlatch_in <= '1';\n" "\twait for 2 * clk_period;\n" "\tlatch_in <= '0';\n" "\twait for %(wait_time)d * clk_period;\n" "\tASSERT(M_out = \"%(m_res_b)s\") REPORT \"test failed\" SEVERITY ERROR;\n\n" % locals())
def inference_resnet(images): with tf.variable_scope('1'): conv1 = common.conv(images, 64, ksize=7, stride=2) conv1 = common.bn(conv1) pool1 = common.max_pool(conv1) with tf.variable_scope('2'): stack2 = common.res_stack(pool1, [256, 256, 256], pool=False) with tf.variable_scope('3'): stack3 = common.res_stack(stack2, [512, 512, 512, 512]) with tf.variable_scope('4'): stack4 = common.res_stack(stack3, [1024, 1024, 1024, 1024, 1024, 1024]) with tf.variable_scope('5'): stack5 = common.res_stack(stack4, [2048, 2048, 2048]) pool5 = common.global_ave_pool(stack5) with tf.variable_scope('fc'): fc = common.fc(pool5, 1) return fc
def inference_small(images): with tf.variable_scope('1'): conv1 = common.conv(images, 64, ksize=7, stride=2) conv1 = common.bn(conv1) pool1 = common.max_pool(conv1) with tf.variable_scope('2'): stack2 = common.stack(pool1, common.res_block, [64, 64]) pool2 = common.max_pool(stack2) with tf.variable_scope('3'): stack3 = common.stack(pool2, common.res_block, [128, 128]) pool3 = common.max_pool(stack3) with tf.variable_scope('4'): stack4 = common.stack(pool3, common.res_block, [256, 256, 256]) pool4 = common.max_pool(stack4) with tf.variable_scope('5'): stack5 = common.stack(pool4, common.res_block, [512, 512]) pool5 = common.global_ave_pool(stack5) with tf.variable_scope('fc'): fc = common.fc(pool5, 1) return fc
def predict(dataset): vs = DataTraj(dataset, conv(self.dgroup, self.dico, self.Batch._fields), idtraj="aircraft") val_data = TensorDataLoader(vs, batch_size=self.hparams.batch_size, shuffle=False, pin_memory=True) def prepare_batch(batch): return self.Batch(*tuple([xi.cuda() for xi in x] for x in batch)) pred = torchmapf(lambda x: self.forward(x).squeeze(1), prepare_batch, val_data) pred = pred.cpu().numpy() r = torchmapf(lambda x: self.compute_error(x)[0], prepare_batch, val_data).cpu().numpy() r = r / (dataset.countmeasure.values * (dataset.countmeasure.values - 1) / 2) dataset.loc[:, "nnpredlatitude"] = pred[:, [0]] dataset.loc[:, "nnpredlongitude"] = pred[:, [1]] dataset.loc[:, "error"] = r return r
def inference_nvidianet(images): with tf.variable_scope('conv1'): conv1 = common.activation(common.conv(images, 24, ksize=5, stride=2, padding='VALID')) with tf.variable_scope('conv2'): conv2 = common.activation(common.conv(conv1, 36, ksize=5, stride=2, padding='VALID')) with tf.variable_scope('conv3'): conv3 = common.activation(common.conv(conv2, 48, ksize=5, stride=2, padding='VALID')) with tf.variable_scope('conv4'): conv4 = common.activation(common.conv(conv3, 64, ksize=3, stride=1, padding='VALID')) with tf.variable_scope('conv5'): conv5 = common.activation(common.conv(conv4, 64, ksize=3, stride=1, padding='VALID')) with tf.variable_scope('conv6'): conv6 = common.activation(common.conv(conv5, 64, ksize=3, stride=1, padding='VALID')) with tf.variable_scope('conv7'): conv7 = common.activation(common.conv(conv6, 64, ksize=3, stride=1, padding='VALID')) conv7_flat = common.flatten(conv7) with tf.variable_scope('fc1'): fc1 = common.dropout(common.activation(common.fc(conv7_flat, 512)), 0.5) with tf.variable_scope('fc2'): fc2 = common.dropout(common.activation(common.fc(fc1, 128)), 0.625) with tf.variable_scope('fc3'): fc3 = common.dropout(common.activation(common.fc(fc2, 32)), 0.75) with tf.variable_scope('fc4'): fc4 = common.dropout(common.activation(common.fc(fc3, 8)), 0.875) with tf.variable_scope('fc5'): fc5 = tf.atan(common.fc(fc4, 1)) return fc5
def yolo3(input_layer): branch_1,branch_2,conv = backbone.backbone(input_layer) conv = common.conv(conv,(1,512)) conv = common.conv(conv,(3,1024)) conv = common.conv(conv,(1,512)) conv = common.conv(conv,(3,1024)) conv = common.conv(conv,(1,512)) conv_l_branch = common.conv(conv,(3,1024)) l_output = common.conv(conv_l_branch,(1,3 * (NUM_CLASS + 5)),activation = False,bn = False) conv = common.conv(conv,(1,256)) conv = common.upsample(conv,"resize") conv = tf.concat([conv,branch_2],axis = -1) conv = common.conv(conv,(1,256)) conv = common.conv(conv,(3,512)) conv = common.conv(conv,(1,256)) conv = common.conv(conv,(3,512)) conv = common.conv(conv,(1,256)) conv_m_branch = common.conv(conv,(3,512)) m_output = common.conv(conv_m_branch,(1,3 * (NUM_CLASS + 5)),activation = False,bn = False) conv = common.conv(conv,(1,128)) conv = common.upsample(conv,"resize") conv = tf.concat([conv,branch_1],axis = -1) conv = common.conv(conv,(1,128)) conv = common.conv(conv,(3,256)) conv = common.conv(conv,(1,128)) conv = common.conv(conv,(3,256)) conv = common.conv(conv,(1,128)) conv_s_branch = common.conv(conv,(3,256)) s_output = common.conv(conv_s_branch,(1,3 * (NUM_CLASS + 5)),activation = False,bn = False) return [s_output,m_output,l_output]
def put_saltions_inside(self, pz: int, nz: int, concentration: float, positive_diameter_in: float, negative_diameter_in: float, counterions: int, valency_counterion: int, counterion_diameter_in: float, bigger_ion_diameter: float, crystal_pack: bool): # establish the number of inside salt ions first # Note: salt concentration is the concentration of one kind of ions, also the factor of 0.6 is there in order to be consistent with units. volume_box = self.lx * self.ly * self.lz total_nions_inside = int((concentration * 0.6022) * (volume_box * utility.unitlength * utility.unitlength * utility.unitlength)) if (total_nions_inside % pz != 0): total_nions_inside = total_nions_inside - (total_nions_inside % pz) + pz total_pions_inside = abs(nz) * total_nions_inside / pz total_saltions_inside = total_nions_inside + total_pions_inside + counterions print("total_saltions_inside", total_saltions_inside) # express diameter in consistent units bigger_ion_diameter = bigger_ion_diameter / utility.unitlength # the bigger_ion_diameter can be cation or anion depending on their sizes positive_diameter_in = positive_diameter_in / utility.unitlength negative_diameter_in = negative_diameter_in / utility.unitlength counterion_diameter_in = counterion_diameter_in / utility.unitlength # distance of closest approach between the ion and the interface # choosing bigger_ion_diameter to define distance of closest approach helps us to avoid overlapping the ions when we generate salt ions inside r0_x = 0.5 * self.lx - 0.5 * bigger_ion_diameter r0_y = 0.5 * self.ly - 0.5 * bigger_ion_diameter r0_z = 0.5 * self.lz - 0.5 * bigger_ion_diameter # generate salt ions inside ion_pos = [] ion_diameter = [] ion_valency = [] ion_charges = [] ion_masses = [] ion_epsilon = [] if not crystal_pack: while (len(ion_pos) != total_saltions_inside): x = np.random.random() x = (1 - x) * (-r0_x) + x * (r0_x) y = np.random.random() y = (1 - y) * (-r0_y) + y * (r0_y) z = np.random.random() z = (1 - z) * (-r0_z) + z * (r0_z) posvec = np.asarray([x, y, z]) continuewhile = False i = 0 while (i < len(ion_pos) and continuewhile == False): # ensure ions are far enough apart if (common.magnitude_np(posvec - ion_pos[i], axis=0) <= (0.5 * bigger_ion_diameter + 0.5 * ion_diameter[i])): continuewhile = True i += 1 if (continuewhile == True): continue if (len(ion_pos) < counterions): ion_diameter.append(counterion_diameter_in) ion_valency.append(valency_counterion) ion_charges.append(valency_counterion * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) elif (len(ion_pos) >= counterions and len(ion_pos) < (total_pions_inside + counterions)): ion_diameter.append(positive_diameter_in) ion_valency.append(pz) ion_charges.append(pz * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) else: ion_diameter.append(negative_diameter_in) ion_valency.append(nz) ion_charges.append(nz * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) ion_pos.append( posvec) # copy the salt ion to the stack of all ions else: num_ions_in_lx = int(self.lx / bigger_ion_diameter) num_ions_in_ly = int(self.ly / bigger_ion_diameter) num_ions_in_lz = int(self.lz / bigger_ion_diameter) for i in range(num_ions_in_lx): x = (-self.lx / 2 + (0.5 * bigger_ion_diameter)) + i * bigger_ion_diameter for j in range(num_ions_in_ly): y = (-self.ly / 2 + (0.5 * bigger_ion_diameter)) + j * bigger_ion_diameter for k in range(num_ions_in_lz): if len(ion_pos) < total_saltions_inside: z = (-self.lz / 2 + (0.5 * bigger_ion_diameter) ) + k * bigger_ion_diameter posvec = np.array([x, y, z]) if (x > ((self.lx / 2) - (0.5 * bigger_ion_diameter)) or y > ((self.ly / 2) - (0.5 * bigger_ion_diameter)) or z > ((self.lz / 2) - (0.5 * bigger_ion_diameter))): continue if (len(ion_pos) < counterions): ion_diameter.append(counterion_diameter_in) ion_valency.append(valency_counterion) ion_charges.append(valency_counterion * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) elif (len(ion_pos) >= counterions and len(ion_pos) < (total_pions_inside + counterions)): ion_diameter.append(positive_diameter_in) ion_valency.append(pz) ion_charges.append(pz * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) else: ion_diameter.append(negative_diameter_in) ion_valency.append(nz) ion_charges.append(nz * 1.0) ion_masses.append(1.0) ion_epsilon.append(self.ein) ion_pos.append(posvec) return {ion_pos_str:conv(ion_pos), ion_charges_str:conv(ion_charges),\ ion_masses_str:conv(ion_masses), ion_diameters_str:conv(ion_diameter), ion_epsilon_str:conv(ion_epsilon)}
def discretize(self, smaller_ion_diameter: float, f: float, charge_meshpoint: float): print("charge_meshpoint", charge_meshpoint) self.width = f * self.lx nx = int(self.lx / self.width) ny = int(self.ly / self.width) left_plane = { "posvec": [], "q": [], "epsilon": [], "a": [], "normalvec": [] } right_plane = { "posvec": [], "q": [], "epsilon": [], "a": [], "normalvec": [] } area = self.width * self.width # creating a discretized hard wall interface at z = - l/2 for j in range(ny): for i in range(nx): position = conv([ -0.5 * self.lx + 0.5 * smaller_ion_diameter + i * self.width, -0.5 * self.ly + 0.5 * smaller_ion_diameter + j * self.width, -0.5 * self.lz ]) normal = conv([0, 0, -1]) left_plane["posvec"].append(position) left_plane["q"].append(charge_meshpoint) left_plane["epsilon"].append(self.eout) left_plane["a"].append(area) left_plane["normalvec"].append(normal) # creating a discretized hard wall interface at z = l/2 for j in range(ny): for i in range(nx): position = conv([ -0.5 * self.lx + 0.5 * smaller_ion_diameter + i * self.width, -0.5 * self.ly + 0.5 * smaller_ion_diameter + j * self.width, 0.5 * self.lz ]) normal = conv([0, 0, 1]) right_plane["posvec"].append(position) right_plane["q"].append(charge_meshpoint) right_plane["epsilon"].append(self.eout) right_plane["a"].append(area) right_plane["normalvec"].append(normal) for key in left_plane.keys(): left_plane[key] = conv(left_plane[key]) for key in right_plane.keys(): right_plane[key] = conv(right_plane[key]) self.left_plane = left_plane self.right_plane = right_plane self.tf_left_plane, self.tf_place_left_plane = common.make_tf_versions_of_dict( left_plane) self.tf_right_plane, self.tf_place_right_plane = common.make_tf_versions_of_dict( right_plane)