def conv_int8( value ): if( len(value) == 0 ): rval = imiss else: rval = int( value ) assert numpy.int8( rval ) == numpy.int32( rval ) , " conv_int8: value out of range" return numpy.int8( rval )
def multi_where(vec1, vec2): '''Given two vectors, multi_where returns a tuple of indices where those two vectors overlap. ****THIS FUNCTION HAS NOT BEEN TESTED ON N-DIMENSIONAL ARRAYS******* Inputs: 2 numpy vectors Output: (xy, yx) where xy is a numpy vector containing the indices of the elements in vector 1 that are also in vector 2. yx is a vector containing the indices of the elements in vector 2 that are also in vector 1. Example: >> x = np.array([1,2,3,4,5]) >> y = np.array([3,4,5,6,7]) >> (xy,yx) = multi_where(x,y) >> xy array([2,3,4]) >> yx array([0,1,2]) ''' OneInTwo = np.array([]) TwoInOne = np.array([]) for i in range(vec1.shape[0]): if np.where(vec2 == vec1[i])[0].shape[0]: OneInTwo = np.append(OneInTwo,i) TwoInOne = np.append(TwoInOne, np.where(vec2 == vec1[i])[0][0]) return (np.int8(OneInTwo), np.int8(TwoInOne))
def testInt(self): num = np.int(2562010) self.assertEqual(np.int(ujson.decode(ujson.encode(num))), num) num = np.int8(127) self.assertEqual(np.int8(ujson.decode(ujson.encode(num))), num) num = np.int16(2562010) self.assertEqual(np.int16(ujson.decode(ujson.encode(num))), num) num = np.int32(2562010) self.assertEqual(np.int32(ujson.decode(ujson.encode(num))), num) num = np.int64(2562010) self.assertEqual(np.int64(ujson.decode(ujson.encode(num))), num) num = np.uint8(255) self.assertEqual(np.uint8(ujson.decode(ujson.encode(num))), num) num = np.uint16(2562010) self.assertEqual(np.uint16(ujson.decode(ujson.encode(num))), num) num = np.uint32(2562010) self.assertEqual(np.uint32(ujson.decode(ujson.encode(num))), num) num = np.uint64(2562010) self.assertEqual(np.uint64(ujson.decode(ujson.encode(num))), num)
def test_NumPy_arrayview_deletion_sitkImage_1(self): # 2D image image = sitk.Image(sizeX, sizeY, sitk.sitkInt32) for j in range(sizeY): for i in range(sizeX): image[i, j] = j*sizeX + i npview = sitk.GetArrayFromImage(image, arrayview = True, writeable = True) image.SetPixel(0,0, newSimpleITKPixelValueInt32) del image carr = np.array(npview, copy = False) rarr = np.reshape(npview, (1, npview.size)) varr = npview.view(dtype=np.int8) self.assertEqual( carr[0,0],newSimpleITKPixelValueInt32) self.assertEqual( rarr[0,0],newSimpleITKPixelValueInt32) self.assertEqual( varr[0,0],np.int8(newSimpleITKPixelValueInt32)) npview[0,0] = newNumPyElementValueInt32 del npview self.assertEqual( carr[0,0],newNumPyElementValueInt32) self.assertEqual( rarr[0,0],newNumPyElementValueInt32) self.assertEqual( varr[0,0],np.int8(newNumPyElementValueInt32))
def testIntMax(self): num = np.int(np.iinfo(np.int).max) self.assertEqual(np.int(ujson.decode(ujson.encode(num))), num) num = np.int8(np.iinfo(np.int8).max) self.assertEqual(np.int8(ujson.decode(ujson.encode(num))), num) num = np.int16(np.iinfo(np.int16).max) self.assertEqual(np.int16(ujson.decode(ujson.encode(num))), num) num = np.int32(np.iinfo(np.int32).max) self.assertEqual(np.int32(ujson.decode(ujson.encode(num))), num) num = np.uint8(np.iinfo(np.uint8).max) self.assertEqual(np.uint8(ujson.decode(ujson.encode(num))), num) num = np.uint16(np.iinfo(np.uint16).max) self.assertEqual(np.uint16(ujson.decode(ujson.encode(num))), num) num = np.uint32(np.iinfo(np.uint32).max) self.assertEqual(np.uint32(ujson.decode(ujson.encode(num))), num) if platform.architecture()[0] != '32bit': num = np.int64(np.iinfo(np.int64).max) self.assertEqual(np.int64(ujson.decode(ujson.encode(num))), num) # uint64 max will always overflow as it's encoded to signed num = np.uint64(np.iinfo(np.int64).max) self.assertEqual(np.uint64(ujson.decode(ujson.encode(num))), num)
def chain2image(chaincode,start_pix): """ Method to compute the pixel contour providing the chain code string and the starting pixel location [X,Y]. Author: Xavier Bonnin (LESIA) """ if (type(chaincode) != str): print "First input argument must be a string!" return None if (len(start_pix) != 2): print "Second input argument must be a 2-elements vector!" return None ardir = np.array([[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]) ccdir = np.array([0,7,6,5,4,3,2,1]) X=[start_pix[0]] Y=[start_pix[1]] for c in chaincode: if (abs(np.int8(c)) > 7): print "Wrong chain code format!" return None wc = np.where(np.int8(c) == np.int8(ccdir))[0] X.append(X[-1] + np.int(ardir[wc,0])) Y.append(Y[-1] + np.int(ardir[wc,1])) return X,Y
def test_numpy_scalar_conversion_values(self): self.assertEqual(nd.as_py(nd.array(np.bool_(True))), True) self.assertEqual(nd.as_py(nd.array(np.bool_(False))), False) self.assertEqual(nd.as_py(nd.array(np.int8(100))), 100) self.assertEqual(nd.as_py(nd.array(np.int8(-100))), -100) self.assertEqual(nd.as_py(nd.array(np.int16(20000))), 20000) self.assertEqual(nd.as_py(nd.array(np.int16(-20000))), -20000) self.assertEqual(nd.as_py(nd.array(np.int32(1000000000))), 1000000000) self.assertEqual(nd.as_py(nd.array(np.int64(-1000000000000))), -1000000000000) self.assertEqual(nd.as_py(nd.array(np.int64(1000000000000))), 1000000000000) self.assertEqual(nd.as_py(nd.array(np.int32(-1000000000))), -1000000000) self.assertEqual(nd.as_py(nd.array(np.uint8(200))), 200) self.assertEqual(nd.as_py(nd.array(np.uint16(50000))), 50000) self.assertEqual(nd.as_py(nd.array(np.uint32(3000000000))), 3000000000) self.assertEqual(nd.as_py(nd.array(np.uint64(10000000000000000000))), 10000000000000000000) self.assertEqual(nd.as_py(nd.array(np.float32(2.5))), 2.5) self.assertEqual(nd.as_py(nd.array(np.float64(2.5))), 2.5) self.assertEqual(nd.as_py(nd.array(np.complex64(2.5-1j))), 2.5-1j) self.assertEqual(nd.as_py(nd.array(np.complex128(2.5-1j))), 2.5-1j) if np.__version__ >= '1.7': self.assertEqual(nd.as_py(nd.array(np.datetime64('2000-12-13'))), date(2000, 12, 13))
def add_vars_to_grp(grp,types, **kwargs): v = grp.createVariable(kwargs.get('var1','var1'),numpy.int8) v[:] = numpy.int8(8) v.foo = 'bar' v = grp.createVariable(kwargs.get('var2','var2'),numpy.int8, (dim3._name,), fill_value=5) v[:] = numpy.int8(8) v.foo = 'bar' v = grp.createVariable(kwargs.get('var3','var3'),numpy.int8, (dim1._name,dim4._name,)) v[:] = numpy.arange(8,dtype=numpy.int8).reshape(2,4) v.foo = 'bar' v = grp.createVariable(kwargs.get('var4','var4'),'S1', (dim1._name,dim4._name,)) #v[:] = numpy.ndarray(8,dtype='S1').reshape(2,4) v[:] = 'a' v.foo = 'bar' for num,type in enumerate(types): default_name = 'var{}'.format(num+5) print default_name v = grp.createVariable(kwargs.get(default_name,default_name),type, (dim4._name,)) try: v[:] = numpy.iinfo(type).max continue except ValueError: pass try: for i,c in enumerate('char'): v[i] = c continue except ValueError: pass v[:] = numpy.pi
def test_valid(self): prop = bcpp.Int() assert prop.is_valid(None) assert prop.is_valid(0) assert prop.is_valid(1) assert prop.is_valid(np.int8(0)) assert prop.is_valid(np.int8(1)) assert prop.is_valid(np.int16(0)) assert prop.is_valid(np.int16(1)) assert prop.is_valid(np.int32(0)) assert prop.is_valid(np.int32(1)) assert prop.is_valid(np.int64(0)) assert prop.is_valid(np.int64(1)) assert prop.is_valid(np.uint8(0)) assert prop.is_valid(np.uint8(1)) assert prop.is_valid(np.uint16(0)) assert prop.is_valid(np.uint16(1)) assert prop.is_valid(np.uint32(0)) assert prop.is_valid(np.uint32(1)) assert prop.is_valid(np.uint64(0)) assert prop.is_valid(np.uint64(1)) # TODO (bev) should fail assert prop.is_valid(False) assert prop.is_valid(True)
def process(self, image, dark=None, variance=None, dark_variance=None, normalization_factor=1.0 ): """Perform the pixel-wise operation of the array :param raw: numpy array with the input image :param dark: numpy array with the dark-current image :param variance: numpy array with the variance of input image :param dark_variance: numpy array with the variance of dark-current image :param normalization_factor: divide the result by this :return: array with processed data, may be an array of (data,variance,normalization) depending on class initialization """ with self.sem: if id(image) != id(self.on_device.get("image")): self.send_buffer(image, "image") if dark is not None: do_dark = numpy.int8(1) if id(dark) != id(self.on_device.get("dark")): self.send_buffer(dark, "dark") else: do_dark = numpy.int8(0) if (variance is not None) and self.on_host.get("calc_variance"): if id(variance) != id(self.on_device.get("variance")): self.send_buffer(variance, "variance") if (dark_variance is not None) and self.on_host.get("calc_variance"): if id(dark_variance) != id(self.on_device.get("dark_variance")): self.send_buffer(dark_variance, "dark_variance") if self.on_host.get("poissonian"): kernel_name = "corrections3Poisson" elif self.on_host.get("calc_variance"): kernel_name = "corrections3" elif self.on_host.get("split_result"): kernel_name = "corrections2" else: kernel_name = "corrections" kwargs = self.cl_kernel_args[kernel_name] kwargs["do_dark"] = do_dark kwargs["normalization_factor"] = numpy.float32(normalization_factor) if (kernel_name == "corrections3") and (self.on_device.get("dark_variance") is not None): kwargs["do_dark_variance"] = do_dark kernel = self.kernels.get_kernel(kernel_name) evt = kernel(self.queue, (self.size,), None, *list(kwargs.values())) if kernel_name.startswith("corrections3"): dest = numpy.empty(self.on_device.get("image").shape + (3,), dtype=numpy.float32) elif kernel_name == "corrections2": dest = numpy.empty(self.on_device.get("image").shape + (2,), dtype=numpy.float32) else: dest = numpy.empty(self.on_device.get("image").shape, dtype=numpy.float32) copy_result = pyopencl.enqueue_copy(self.queue, dest, self.cl_mem["output"]) copy_result.wait() if self.profile: self.events += [EventDescription("preproc", evt), EventDescription("copy result", copy_result)] return dest
def test_numpy(self): assert chash(np.bool_(True)) == chash(np.bool_(True)) assert chash(np.int8(1)) == chash(np.int8(1)) assert chash(np.int16(1)) assert chash(np.int32(1)) assert chash(np.int64(1)) assert chash(np.uint8(1)) assert chash(np.uint16(1)) assert chash(np.uint32(1)) assert chash(np.uint64(1)) assert chash(np.float32(1)) == chash(np.float32(1)) assert chash(np.float64(1)) == chash(np.float64(1)) assert chash(np.float128(1)) == chash(np.float128(1)) assert chash(np.complex64(1+1j)) == chash(np.complex64(1+1j)) assert chash(np.complex128(1+1j)) == chash(np.complex128(1+1j)) assert chash(np.complex256(1+1j)) == chash(np.complex256(1+1j)) assert chash(np.datetime64('2000-01-01')) == chash(np.datetime64('2000-01-01')) assert chash(np.timedelta64(1,'W')) == chash(np.timedelta64(1,'W')) self.assertRaises(ValueError, chash, np.object()) assert chash(np.array([[1, 2], [3, 4]])) == \ chash(np.array([[1, 2], [3, 4]])) assert chash(np.array([[1, 2], [3, 4]])) != \ chash(np.array([[1, 2], [3, 4]]).T) assert chash(np.array([1, 2, 3])) == chash(np.array([1, 2, 3])) assert chash(np.array([1, 2, 3], dtype=np.int32)) != \ chash(np.array([1, 2, 3], dtype=np.int64))
def result_dict_to_hdf5(f, rd): for name, data in rd.items(): flag = None # beware: isinstance(True/False, int) == True if isinstance(data, bool): data = np.int8(data) flag = "py_bool" elif isinstance(data, int): data = np.int64(data) flag = "py_int" if isinstance(data, np.ndarray): dataset = f.create_dataset(name, data=data) else: ty = type(data) if ty is str: ty_h5 = "S{}".format(len(data)) data = data.encode() else: try: ty_h5 = _type_to_hdf5[ty] except KeyError: raise TypeError("Type {} is not supported for HDF5 output" .format(ty)) from None dataset = f.create_dataset(name, (), ty_h5) dataset[()] = data if flag is not None: dataset.attrs[flag] = np.int8(1)
def classify(self, inputs): # switch to test mode self.mode.set_value(np.int8(1)) rval = self._classify(inputs) # switch to train mode self.mode.set_value(np.int8(0)) return rval
def get_sites_summary(noaa_dir, stemxy=False): """create a pandas data frame with site code, lon and lat for all sites with data files in the specified directory ARGS: noaa_dir (string): full path to a directory containing NOAA OCS observation files RETURNS: pandas DataFrame object with columns site_code, lon, lat """ all_sites_df = get_all_NOAA_airborne_data(noaa_dir) if stemxy: dom = domain.STEM_Domain() all_sites_df.get_stem_xy(dom.get_lon(), dom.get_lat()) summary_df = all_sites_df.obs.groupby('sample_site_code').mean() if stemxy: summary_df = summary_df[['sample_longitude', 'sample_latitude', 'x_stem', 'y_stem']] # make sure x, y indices are integers summary_df['x_stem'] = np.int8(np.round(summary_df['x_stem'])) summary_df['y_stem'] = np.int8(np.round(summary_df['y_stem'])) else: summary_df = summary_df[['sample_longitude', 'sample_latitude']] summary_df = summary_df.reset_index() summary_df.rename(columns={k: k.replace('sample_', '') for k in summary_df.columns.values}, inplace=True) return(summary_df)
def process(self, target, **kwargs): """ Filter the image leaving only the required annulus. """ # Check target type if target.name() != 'Image': self.logger.warning("[%s] Input variable is not an image. Skipping.", self.name()) return {'output': None} # Check that inner and outer diameter are defined if self._inner is None or self._outer is None: self.logger.warning("[%s] One of the required diameter is not set. Skipping.", self.name()) return {'output': None} # If size has changed or mask is not defined, we prepare it if self._mask is None or target.value.shape[1:] != self._size: self._size = target.value.shape[1:] if self._center is None: self._center = [int(target.value.shape[2] / 2), int(target.value.shape[1] / 2)] # Build the mask y, x = np.ogrid[0:self._size[0], 0:self._size[1]] x -= self._center[0] y -= self._center[1] r_in = x ** 2 / self._inner[0] + y ** 2 / self._inner[1] r_out = x ** 2 / self._outer[0] + y ** 2 / self._outer[1] self._mask = np.int8(r_in > 1) * np.int8(r_out < 1) # Filter the image using the defined mask self.logger.debug("[%s] Image shape %s, Mask shape %s.", self.name(), target.value.shape, self._mask.shape) out = Image() out.value = np.copy(target.value) * np.tile(self._mask, (target.value.shape[0], 1, 1)) return {'output': out}
def test_apply_scaling(): # Null scaling, same array returned arr = np.zeros((3,), dtype=np.int16) assert_true(apply_read_scaling(arr) is arr) assert_true(apply_read_scaling(arr, np.float64(1.0)) is arr) assert_true(apply_read_scaling(arr, inter=np.float64(0)) is arr) f32, f64 = np.float32, np.float64 f32_arr = np.zeros((1,), dtype=f32) i16_arr = np.zeros((1,), dtype=np.int16) # Check float upcast (not the normal numpy scalar rule) # This is the normal rule - no upcast from scalar assert_equal((f32_arr * f64(1)).dtype, np.float32) assert_equal((f32_arr + f64(1)).dtype, np.float32) # The function does upcast though ret = apply_read_scaling(np.float32(0), np.float64(2)) assert_equal(ret.dtype, np.float64) ret = apply_read_scaling(np.float32(0), inter=np.float64(2)) assert_equal(ret.dtype, np.float64) # Check integer inf upcast big = f32(type_info(f32)['max']) # Normally this would not upcast assert_equal((i16_arr * big).dtype, np.float32) # An equivalent case is a little hard to find for the intercept nmant_32 = type_info(np.float32)['nmant'] big_delta = np.float32(2**(floor_log2(big)-nmant_32)) assert_equal((i16_arr * big_delta + big).dtype, np.float32) # Upcasting does occur with this routine assert_equal(apply_read_scaling(i16_arr, big).dtype, np.float64) assert_equal(apply_read_scaling(i16_arr, big_delta, big).dtype, np.float64) assert_equal(apply_read_scaling(np.int8(0), -1.0, 0.0).dtype, np.float32) assert_equal(apply_read_scaling(np.int8(0), 1e38, 0.0).dtype, np.float64) assert_equal(apply_read_scaling(np.int8(0), -1e38, 0.0).dtype, np.float64)
def test_is_int(): # is int assert isinstance(1, int) is True assert isinstance(np.int(1), int) is True assert isinstance(np.int8(1), int) is False assert isinstance(np.int16(1), int) is False if PY3: assert isinstance(np.int32(1), int) is False elif PY2: assert isinstance(np.int32(1), int) is True assert isinstance(np.int64(1), int) is False # is np.int assert isinstance(np.int(1), np.int) is True assert isinstance(np.int8(1), np.int) is False assert isinstance(np.int16(1), np.int) is False if PY3: assert isinstance(np.int32(1), np.int) is False elif PY2: assert isinstance(np.int32(1), np.int) is True assert isinstance(np.int64(1), np.int) is False
def parse_objects(self, data): x = y = dx = dy = count = 0 addr = None objects = [] data = np.array(data, dtype=np.uint8) last = len(data) index = 0 while index < last: c = data[index] log.debug("index=%d, command=%x" % (index, c)) self.pick_index += 1 index += 1 command = None if c < 0xfb: if addr is not None: obj = self.get_object(self.pick_index, x, y, c, dx, dy, addr) objects.append(obj) elif c >= 0xfc and c <= 0xfe: arg1 = data[index] arg2 = data[index + 1] index += 2 if c == 0xfc: addr = arg2 * 256 + arg1 elif c == 0xfd: x = int(arg1) y = int(arg2) else: dx = int(np.int8(arg1)) # signed! dy = int(np.int8(arg2)) elif c == 0xff: last = 0 # force the end return objects
def moveObject(initial_depthMAT): ########################################################################### ## Checking each pixel and invoking functions to process pixels on the vessels. ########################################################################### global done,startx,starty,clock,screen,endx,endy global im global endpoint global current_depth global depthMAT global rough_range global modified_depthMAT,mask_depthMAT if np.amax(im)!=1: ret,im = cv2.threshold(im, 250, 1, cv2.THRESH_BINARY) else: print np.amax(im) np.int8(im) mask_depthMAT=initial_depthMAT modified_depthMAT=initial_depthMAT depthMAT=getDepth(im,modified_depthMAT) rough_range=np.median(depthMAT[depthMAT>0])/LEVEL im0=np.copy(im) convalue_n=Neigh_Cov(im0) cols=im.shape[1] rows=im.shape[0] for y in range(0,rows,1): for x in range(0,cols,1): if im[y][x]==1: fillPixel(x,y,convalue_n) return convalue_n
def xeng_in_unpack(oob, start_index): sum_polQ_r = 0 sum_polQ_i = 0 sum_polI_r = 0 sum_polI_i = 0 rcvd_errs = 0 flag_errs = 0 #average the packet contents from the very first entry for slice_index in range(c.config['xeng_acc_len']): abs_index = start_index + slice_index polQ_r = (oob[abs_index]['data'] & ((2**(16)) - (2**(12))))>>(12) polQ_i = (oob[abs_index]['data'] & ((2**(12)) - (2**(8))))>>(8) polI_r = (oob[abs_index]['data'] & ((2**(8)) - (2**(4))))>>(4) polI_i = (oob[abs_index]['data'] & ((2**(4)) - (2**(0))))>>0 #square each number and then sum it sum_polQ_r += (float(((numpy.int8(polQ_r << 4)>> 4)))/(2**binary_point))**2 sum_polQ_i += (float(((numpy.int8(polQ_i << 4)>> 4)))/(2**binary_point))**2 sum_polI_r += (float(((numpy.int8(polI_r << 4)>> 4)))/(2**binary_point))**2 sum_polI_i += (float(((numpy.int8(polI_i << 4)>> 4)))/(2**binary_point))**2 if not oob[abs_index]['received']: rcvd_errs += 1 if oob[abs_index]['flag']: flag_errs += 1 num_accs = c.config['xeng_acc_len'] level_polQ_r = numpy.sqrt(float(sum_polQ_r)/ num_accs) level_polQ_i = numpy.sqrt(float(sum_polQ_i)/ num_accs) level_polI_r = numpy.sqrt(float(sum_polI_r)/ num_accs) level_polI_i = numpy.sqrt(float(sum_polI_i)/ num_accs) rms_polQ = numpy.sqrt(((level_polQ_r)**2) + ((level_polQ_i)**2)) rms_polI = numpy.sqrt(((level_polI_r)**2) + ((level_polI_i)**2)) if level_polQ_r < 1.0/(2**num_bits): ave_bits_used_Q_r = 0 else: ave_bits_used_Q_r = numpy.log2(level_polQ_r*(2**binary_point)) if level_polQ_i < 1.0/(2**num_bits): ave_bits_used_Q_i = 0 else: ave_bits_used_Q_i = numpy.log2(level_polQ_i*(2**binary_point)) if level_polI_r < 1.0/(2**num_bits): ave_bits_used_I_r = 0 else: ave_bits_used_I_r = numpy.log2(level_polI_r*(2**binary_point)) if level_polI_i < 1.0/(2**num_bits): ave_bits_used_I_i = 0 else: ave_bits_used_I_i = numpy.log2(level_polI_i*(2**binary_point)) return {'rms_polQ':rms_polQ,\ 'rms_polI':rms_polI,\ 'rcvd_errs':rcvd_errs,\ 'flag_errs':flag_errs,\ 'ave_bits_used_Q_r':ave_bits_used_Q_r,\ 'ave_bits_used_Q_i':ave_bits_used_Q_i,\ 'ave_bits_used_I_r':ave_bits_used_I_r,\ 'ave_bits_used_I_i':ave_bits_used_I_i}
def main_boost(): train_ratio = 0.5 src = Searcher('nail_image500.db') # get histogram HSV_hist = np.loadtxt(HSV_fname) # fHSVのヒストグラムを読み込む # normalize HSV hist HSV_max = np.max(HSV_hist, axis = 1) HSV_min = np.min(HSV_hist, axis = 1) HSV_rang = (HSV_max -HSV_min).reshape((len(HSV_max), 1)) HSV_hist_norm = [(HSV_hist[i] - HSV_min[i])/HSV_rang[i] for i in xrange(len(HSV_rang))] samples = np.array( src.get_hist() , dtype = np.float32) # normalize BoW(samples) hist smp_max = np.max(samples, axis = 1) smp_min = np.min(samples, axis = 1) smp_rang = (smp_max - smp_min).reshape((len(smp_max), 1)) smp_norm = [(samples[i] - smp_min[i])/smp_rang[i] for i in xrange(len(smp_rang))] samples = np.hstack((smp_norm, HSV_hist_norm)) #samples = np.hstack((samples, HSV_hist)) # get labels(object) responses = np.int8(next(csv.reader(file(csvfile, 'r'), delimiter=','))) responses[responses==-1] = 0 # get HSV area flag() hsv_flag = np.int8(next(csv.reader(file(hsv_flag_fname, 'r'), delimiter=','))) # get sample indexes train_idx = random.sample( range(len(samples)), int(len(samples)*train_ratio) ) test_idx = range(len(samples)) # initialize test index for t in train_idx: test_idx.remove(t) # remove train index. and create test index. # implement Model boost = Boost() # create model boost.train(samples[train_idx,:], responses[train_idx]) boost.save('test_boost') # predict use created model print "raw",boost.predict(samples[test_idx]) print "test_rst",responses[test_idx] print "hsv_flag", hsv_flag[test_idx] train_rate = np.mean(boost.predict(samples[train_idx]) == responses[train_idx]) train_res = boost.predict(samples[test_idx]) test_rate = np.mean(train_res == responses[test_idx]) # テストの結果をhsvによって補正する revision = deepcopy(train_res) revision[ hsv_flag[test_idx]==1 ] = 1 res_rate = np.mean(revision == responses[test_idx]) print "revision", revision print "train",train_rate print "test",test_rate print "res_rate",res_rate
def read_serial_thread(): # all global variables this function can modify: global IR_0, IR_1, IR_2, IR_3, IR_4, IR_Yaw_right, IR_Yaw_left, Yaw, p_part, alpha, Kp, Kd, AUTO_STATE, manual_state, mode, blue_percentage while 1: no_of_bytes_waiting = serial_port.inWaiting() if no_of_bytes_waiting > 19: # the ardu sends 20 bytes at the time (18 data, 2 control) # read the first byte (read 1 byte): (ord: gives the actual value of the byte) first_byte = np.uint8(ord(serial_port.read(size = 1))) # read all data bytes if first byte was the start byte: if first_byte == 100: serial_data = [] # read all data bytes: for counter in range(18): # 18 data bytes is sent from the ardu serial_data.append(ord(serial_port.read(size = 1))) # read the received checksum: checksum = np.uint8(ord(serial_port.read(size = 1))) # calculate checksum for the received data bytes: (pleae note that the use of uint8 and int8 exactly match what is sent from the arduino) calc_checksum = np.uint8(np.uint8(serial_data[0]) + np.uint8(serial_data[1]) + np.uint8(serial_data[2]) + np.uint8(serial_data[3]) + np.uint8(serial_data[4]) + np.int8(serial_data[5]) + np.int8(serial_data[6]) + np.int8(serial_data[7]) + np.int8(serial_data[8]) + np.int8(serial_data[9]) + np.int8(serial_data[10]) + np.uint8(serial_data[11]) + np.uint8(serial_data[12]) + np.uint8(serial_data[13]) + np.uint8(serial_data[14]) + np.uint8(serial_data[15]) + np.uint8(serial_data[16]) + np.uint8(serial_data[17])) # update the variables with the read serial data only if the checksums match: if calc_checksum == checksum: IR_0 = int(np.uint8(serial_data[0])) # (int() is needed to convert it to something that can be sent to the webpage) IR_1 = int(np.uint8(serial_data[1])) IR_2 = int(np.uint8(serial_data[2])) IR_3 = int(np.uint8(serial_data[3])) IR_4 = int(np.uint8(serial_data[4])) IR_Yaw_right = int(np.int8(serial_data[5])) # IR_Yaw_right was sent as an int8_t, but in order to make python treat it as one we first need to tell it so explicitly with the help of numpy, before converting the result (a number between -128 and +127) to the corresponding python int IR_Yaw_left = int(np.int8(serial_data[6])) Yaw = int(np.int8(serial_data[7])) p_part = int(np.int8(serial_data[8])) alpha_low_byte = np.uint8(serial_data[9]) alpha_high_byte = np.uint8(serial_data[10]) # yes, we need to first treat both the low and high bytes as uint8:s, try it by hand and a simple example (try sending -1) alpha = int(np.int16(alpha_low_byte + alpha_high_byte*256)) # (mult with 256 corresponds to a 8 bit left shift) Kp = int(np.uint8(serial_data[11])) Kd_low_byte = np.uint8(serial_data[12]) Kd_high_byte = np.uint8(serial_data[13]) Kd = int(Kd_low_byte + Kd_high_byte*256) AUTO_STATE = auto_states[int(np.uint8(serial_data[14]))] # look up the received integer in the auto_states dict manual_state = manual_states[int(np.uint8(serial_data[15]))] mode = mode_states[int(np.uint8(serial_data[16]))] blue_percentage = int(np.uint8(serial_data[17])) else: # if the checksums doesn't match: something weird has happened during transmission: flush input buffer and start over serial_port.flushInput() print("Something went wrong in the transaction: checksums didn't match!") else: # if first byte isn't the start byte: we're not in sync: just read the next byte until we get in sync (until we reach the start byte) pass else: # if not enough bytes for entire transmission, just wait for more data: pass time.sleep(0.025) # Delay for ~40 Hz loop frequency (faster than the sending frequency)
def __call__(self, data): ts = data[self.key] date = datetime.datetime.utcfromtimestamp(ts) yearweek = date.isocalendar()[1] - 1 info = (numpy.int8(51 if yearweek == 52 else yearweek), numpy.int8(date.weekday()), numpy.int8(date.hour * 4 + date.minute / 15)) return info
def feng_unpack(f, hdr_index, pkt_len): sum_polQ_r = 0 sum_polQ_i = 0 sum_polI_r = 0 sum_polI_i = 0 #average the packet contents from the very first entry for pkt_index in range(0, pkt_len): pkt_64bit = snap_data[f]['data'][pkt_index].data for offset in range(0,64,16): polQ_r = (pkt_64bit & ((2**(offset+16)) - (2**(offset+12))))>>(offset+12) polQ_i = (pkt_64bit & ((2**(offset+12)) - (2**(offset+8))))>>(offset+8) polI_r = (pkt_64bit & ((2**(offset+8)) - (2**(offset+4))))>>(offset+4) polI_i = (pkt_64bit & ((2**(offset+4)) - (2**(offset))))>>offset #square each number and then sum it sum_polQ_r += (float(((numpy.int8(polQ_r << 4)>> 4)))/(2**binary_point))**2 sum_polQ_i += (float(((numpy.int8(polQ_i << 4)>> 4)))/(2**binary_point))**2 sum_polI_r += (float(((numpy.int8(polI_r << 4)>> 4)))/(2**binary_point))**2 sum_polI_i += (float(((numpy.int8(polI_i << 4)>> 4)))/(2**binary_point))**2 num_accs = (pkt_len-1)*(64/16) level_polQ_r = numpy.sqrt(float(sum_polQ_r)/ num_accs) level_polQ_i = numpy.sqrt(float(sum_polQ_i)/ num_accs) level_polI_r = numpy.sqrt(float(sum_polI_r)/ num_accs) level_polI_i = numpy.sqrt(float(sum_polI_i)/ num_accs) rms_polQ = numpy.sqrt(((level_polQ_r)**2) + ((level_polQ_i)**2)) rms_polI = numpy.sqrt(((level_polI_r)**2) + ((level_polI_i)**2)) if level_polQ_r < 1.0/(2**num_bits): ave_bits_used_Q_r = 0 else: ave_bits_used_Q_r = numpy.log2(level_polQ_r*(2**num_bits)) if level_polQ_i < 1.0/(2**num_bits): ave_bits_used_Q_i = 0 else: ave_bits_used_Q_i = numpy.log2(level_polQ_i*(2**num_bits)) if level_polI_r < 1.0/(2**num_bits): ave_bits_used_I_r = 0 else: ave_bits_used_I_r = numpy.log2(level_polI_r*(2**num_bits)) if level_polI_i < 1.0/(2**num_bits): ave_bits_used_I_i = 0 else: ave_bits_used_I_i = numpy.log2(level_polI_i*(2**num_bits)) return {'rms_polQ':rms_polQ,\ 'rms_polI':rms_polI,\ 'ave_bits_used_Q_r':ave_bits_used_Q_r,\ 'ave_bits_used_Q_i':ave_bits_used_Q_i,\ 'ave_bits_used_I_r':ave_bits_used_I_r,\ 'ave_bits_used_I_i':ave_bits_used_I_i}
def test_byteDblArray(self): print "Testing double byteArray" arr = javaPrimativeArray.make_dbl_array('byte',2,3) self.assertIsInstance(arr, javaArray.get_array_type(javaPrimativeArray.get_array_type('byte'))) self.assertIsInstance(arr.o, javabridge.JB_Object) arr[0][0] = np.int8(2) arr[1][1] = np.int8(3) self.assertIsInstance(arr[0][0], metaByte) self.assertEqual(arr[1][1],np.int8(3))
def MAP(z, M500): #Create the two arrays we need (radial distance and temp) R500 = ((M500)/((4./3.)*(np.pi)*(500.)*(Rho_Crit(z))))**(1./3.) PNORM = (1.65e-3)*((E_FACT(z))**(8./3.))*((((hubble70)*(M500))/(3.0e14))**(2./3. + alpha_p))*((hubble70)**2.)*((8.403)/((hubble70)**(3./2.)))*(1.0e6) x = np.arange(0,(100.)*(6.)*(R500)/(100.), 0.01) q = np.zeros(len(x)) for i in range(len(x)): y1= x[i] r = y1 upperlim = np.sqrt(((6.)*(R500))**(2.) - (r)**(2.)) def ARNAUD_PROJ(x1): return (1.)/(((((c500/R500)**2.)*((x1**2. + y1**2.)))**(gamma/2.))*((1. + (((c500/R500)**2.)*(x1**2. + y1**2.))**(alpha/2))**(index))) if r < (6.)*(R500): q[i] = scipy.integrate.romberg(ARNAUD_PROJ,0.001, upperlim, divmax=20) elif r >(6.)*(R500): break c = ((x)*(c500))/(R500) f = (y_const)*(q)*(PNORM)*(2.)*(mpc) r_over_r500= (c)/((c500))*(R500) r_arcmin =(r_over_r500)/(ANG_DIAM_DIST(z))*(180.)/(np.pi)*(60.) dT_uK = (f)*(1.0e6)*(2.73) r = r_arcmin t = dT_uK #Round the radial distance array up to the nearest odd number MaxR = np.int8(np.ceil(np.max(r))) if MaxR %2 == 0: MaxR = MaxR +1 else: MaxR = MaxR Dim = np.int8(np.ceil((MaxR)/(np.sqrt(2)))) #Create meshgrid of 2*MaxR by 2*MaxR by quarter units vects = np.linspace(0,2*Dim,2*Dim*4+1) x,y = np.meshgrid(vects, vects) #Create empty 2d arrays for radial distance calculation and temp population #with same dimesions of the meshgrid DistR = np.zeros((2*Dim*4+1, 2*Dim*4+1)) T_at_R = np.zeros((2*Dim*4+1, 2*Dim*4+1)) #Populate DistR with radial distances from center to all other points for i in range(2*Dim*4+1): for j in range(2*Dim*4+1): DistR[i,j] = np.sqrt((x[Dim*4,Dim*4] - x[i,j])**2 +(y[Dim*4,Dim*4] - y[i,j])**2) #Populate T_at_R with temp values corresponding to radial distances R = r T = t interpol = interp1d(R,T, kind='cubic', bounds_error=False, fill_value=0) for i in range(2*Dim*4+1): for j in range(2*Dim*4+1): T_at_R[i,j] = interpol(DistR[i,j]) plt.imshow(T_at_R) #for i in range(2*Dim*4+1): #for j in range(2*Dim*4+1): #if T_at_R[i,j] <=np.min(t): #T_at_R[i,j] = 0 return DistR, T_at_R[27]
def xaui_feng_unpack(xeng, xaui_port, bram_dump, hdr_index, pkt_len, skip_indices): ''' Unpack F-engine data? ''' pkt_64bit = struct.unpack('>Q',bram_dmp['bram_msb'][(4 * hdr_index) : (4 * hdr_index) + 4] + bram_dmp['bram_lsb'][(4 * hdr_index):(4 * hdr_index) + 4])[0] pkt_mcnt =(pkt_64bit&((2**64) - (2**16))) >> 16 pkt_ant = xeng*c.config['n_xaui_ports_per_xfpga'] * c.config['n_ants_per_xaui'] + xaui_port * c.config['n_ants_per_xaui'] + pkt_64bit & ((2**16)-1) pkt_freq = pkt_mcnt % n_chans sum_polQ_r = 0 sum_polQ_i = 0 sum_polI_r = 0 sum_polI_i = 0 # average the packet contents - ignore first entry (header) for pkt_index in range(1, pkt_len): abs_index = hdr_index + pkt_index if skip_indices.count(abs_index)>0: print 'Skipped %i' % abs_index continue pkt_64bit = struct.unpack('>Q',bram_dmp['bram_msb'][(4 * abs_index):(4 * abs_index) + 4] + bram_dmp['bram_lsb'][(4 * abs_index):(4 * abs_index) + 4])[0] for offset in range(64, 0, -16): polQ_r = (pkt_64bit & ((2**(offset + 16)) - (2**(offset + 12)))) >> (offset + 12) polQ_i = (pkt_64bit & ((2**(offset + 12)) - (2**(offset + 8)))) >> (offset + 8) polI_r = (pkt_64bit & ((2**(offset + 8)) - (2**(offset + 4)))) >> (offset + 4) polI_i = (pkt_64bit & ((2**(offset + 4)) - (2**(offset)))) >> offset # square each number and then sum it sum_polQ_r += (float(((numpy.int8(polQ_r << 4)>> 4)))/(2**binary_point))**2 sum_polQ_i += (float(((numpy.int8(polQ_i << 4)>> 4)))/(2**binary_point))**2 sum_polI_r += (float(((numpy.int8(polI_r << 4)>> 4)))/(2**binary_point))**2 sum_polI_i += (float(((numpy.int8(polI_i << 4)>> 4)))/(2**binary_point))**2 # print 'Processed %i. Sum Qr now %f...'%(abs_index, sum_polQ_r) num_accs = (pkt_len - len(skip_indices)) * (64 / 16) level_polQ_r = numpy.sqrt(float(sum_polQ_r) / num_accs) level_polQ_i = numpy.sqrt(float(sum_polQ_i) / num_accs) level_polI_r = numpy.sqrt(float(sum_polI_r) / num_accs) level_polI_i = numpy.sqrt(float(sum_polI_i) / num_accs) rms_polQ = numpy.sqrt(((level_polQ_r)**2) + ((level_polQ_i)**2)) rms_polI = numpy.sqrt(((level_polI_r)**2) + ((level_polI_i)**2)) return {'pkt_mcnt': pkt_mcnt,\ 'pkt_ant': pkt_ant,\ 'pkt_freq': pkt_freq,\ 'rms_polQ': rms_polQ,\ 'rms_polI': rms_polI,\ 'level_polQ_r': level_polQ_r,\ 'level_polQ_i': level_polQ_i,\ 'level_polI_r': level_polI_r,\ 'level_polI_i': level_polI_i}
def conv_ofc(a,b): la = np.int8(len(a)) # dimensão do vetor de entrada lb = np.int8(len(b)) # dimensão vetor de resposta ao impulso ly = la + lb - 1 # dimensão do vetor da resposta do sistema y = np.zeros(ly,dtype = np.int8) # preenche o vetor com zeros for n in np.arange(0, la) : # n vairia no intervalo [0,lx] for k in np.arange(0, lb) : # k vairia no intervalo [0,lh] y[n + k] += a[n] * b[k] # calcula a convolução entre x[n] e h[n] return y
def VD(pre: np.array, label: np.array): ''' 相对体积误差 :param pre:分割图像 :param label:标签 :return:误差率,float ''' pre_mask = np.int8(pre > 0) label_mask = np.int8(label > 0) return (np.sum(pre_mask) - np.sum(label_mask)) * 1.0 / np.sum(label_mask)
def conv_int8( value ): try: if( len(value) == 0 ): rval = imiss else: rval = int( value ) assert np.int8( rval ) == np.int32( rval ) , " conv_int8: value out of range" return np.int8( rval ) except: return imiss
def _init_quantized_weight(self, _, arr): _arr = random.randint(-127, 127, dtype='int32').asnumpy() arr[:] = np.int8(_arr)
def apply_augmentation(self, example, is_train, output_size): im = cv.imread(example[0]['image'], 1) height, width = im.shape[:2] crop_pos = [width // 2, height // 2] max_d = max(height, width) scales = [output_size / float(max_d), output_size / float(max_d)] centers = [] corners = [] m = np.zeros((height, width)) for j in example: if j['iscrowd']: rle = mask.frPyObjects(j['mask'], height, width) m += mask.decode(rle) m = m < 0.5 m = m.astype(np.float32) for ann in example: if ann['iscrowd']: continue poly = ann['mask'] if len(poly[0]) < 25: continue N = len(poly[0]) X = poly[0][0:N:2] Y = poly[0][1:N:2] c = np.ones((3, 1)) x1, y1 = ann['bbox'][0], ann['bbox'][1] w, h = ann['bbox'][2], ann['bbox'][3] c[0], c[1] = x1 + w / 2, y1 + h / 2 centers.append(c) corner = np.ones((3, len(X))) corner[0, :] = X corner[1, :] = Y corners.append(corner) param = {'rot': 0, 'scale': scales[0], # scale, 'flip': 0, 'tx': 0, 'ty': 0} if is_train: np.random.seed() param['scale'] = scales[0] * (np.random.random() + .5) # scale * (np.random.random() + .5) param['flip'] = np.random.binomial(1, 0.5) param['rot'] = (np.random.random() * (40 * 0.0174532)) - 20 * 0.0174532 param['tx'] = np.int8((np.random.random() * 10) - 5) param['ty'] = np.int8((np.random.random() * 10) - 5) a = param['scale'] * np.cos(param['rot']) b = param['scale'] * np.sin(param['rot']) shift_to_upper_left = np.identity(3) shift_to_center = np.identity(3) t = np.identity(3) t[0][0] = a if param['flip']: t[0][0] = -a t[0][1] = -b t[1][0] = b t[1][1] = a shift_to_upper_left[0][2] = -crop_pos[0] + param['tx'] shift_to_upper_left[1][2] = -crop_pos[1] + param['ty'] shift_to_center[0][2] = output_size / 2 shift_to_center[1][2] = output_size / 2 t_form = np.matmul(t, shift_to_upper_left) t_form = np.matmul(shift_to_center, t_form) centers_warped = [] corners_warped = [] im_cv = cv.warpAffine(im, t_form[0:2, :], (output_size, output_size)) for i, c in enumerate(centers): ct = np.matmul(t_form, c) cr = np.matmul(t_form, corners[i]) cr[0, :] *= cr[0, :] > -1 cr[0, :] *= cr[0, :] < output_size cr[1, :] *= cr[1, :] > 0 cr[1, :] *= cr[1, :] < output_size x1, x2 = min(cr[0, :]), max(cr[0, :]) y1, y2 = min(cr[1, :]), max(cr[1, :]) if x1 == -1 or y1 == -1 or x2 >= output_size or y2 >= output_size: print("prob") w = np.abs(x1 - x2) h = np.abs(y1 - y2) m_dim = np.maximum(w, h) if m_dim == 0: continue corners_warped.append(np.log(m_dim)) centers_warped.append(ct) mw = cv.warpAffine(m*255, t_form[0:2, :], (output_size, output_size))/255 mw = cv.resize(mw, (self.heatmapres, self.heatmapres)) mw = (mw > 0.5).astype(np.float32) hms = self.generate_heatmaps(centers_warped) votes, masks = self.generate_offsets(centers_warped, corners_warped) img = cv.cvtColor(im_cv, cv.COLOR_BGR2RGB) img = torch.from_numpy(img).float() img = torch.transpose(img, 1, 2) img = torch.transpose(img, 0, 1) img /= 255 hms = torch.from_numpy(hms).float() mw = torch.from_numpy(mw) mw = mw.view(1, self.heatmapres, self.heatmapres) return img, hms, mw, votes, masks
QDOUBLE: 'd', QSTRING: 's', QSYMBOL: 'S', QCHAR: 'b', QMONTH: 'i', QDATE: 'i', QDATETIME: 'd', QMINUTE: 'i', QSECOND: 'i', QTIME: 'i', QTIMESPAN: 'q', QTIMESTAMP: 'q', } # null definitions _QNULL1 = numpy.int8(-2**7) _QNULL2 = numpy.int16(-2**15) _QNULL4 = numpy.int32(-2**31) _QNULL8 = numpy.int64(-2**63) _QNAN32 = numpy.frombuffer(b'\x00\x00\xc0\x7f', dtype=numpy.float32)[0] _QNAN64 = numpy.frombuffer(b'\x00\x00\x00\x00\x00\x00\xf8\x7f', dtype=numpy.float64)[0] _QNULL_BOOL = numpy.bool_(False) _QNULL_SYM = numpy.string_('') _QNULL_GUID = uuid.UUID('00000000-0000-0000-0000-000000000000') QNULLMAP = { QGUID: ('0Ng', _QNULL_GUID, lambda v: v == _QNULL_GUID), QBOOL: ('0b', _QNULL_BOOL, lambda v: v == numpy.bool_(False)), QBYTE: ('0x00', _QNULL1, lambda v: v == _QNULL1), QSHORT: ('0Nh', _QNULL2, lambda v: v == _QNULL2),
folder = '/home/mateus/Downloads/iCloud_Photos/' filename = 'imagem8.jpeg' analise = cv2.imread(os.path.join(folder, filename)) analise_data = analise.reshape( [analise.shape[0] * analise.shape[1], analise.shape[2]]) #%% random_forest = RandomForestClassifier(max_depth=12, random_state=0) random_forest.fit(data[:, 0:3], data[:, 3]) #%% result = np.int8(random_forest.predict(analise_data)) #%% codebook = np.linspace(0, 1, n_labels) #codebook = shuffle(colors, random_state=0)[:n_labels] w, h = analise.shape[0:2] image_class = np.zeros([w, h]) label_idx = 0 for i in range(w): for j in range(h): image_class[i, j] = codebook[result[label_idx]] label_idx += 1
def calculate_sim_v_list(self, user, users_area, score_thr, items_types_weights_list): """ To calculate user's similarity vectors for each items_types_weights """ # Validation if user < 0 or user >= self._USERS_SIZE: raise Exception( 'SimVCalculator: calculate_sim_v_list: user is incorrect') if np.any(users_area < 0) or np.any(users_area >= self._USERS_SIZE): raise Exception( 'SimVCalculator: calculate_sim_v_list: users_area contains incorrect user' ) if score_thr <= np.int8(0) or score_thr > np.int8(100): raise Exception( 'SimVCalculator: calculate_sim_v_list: score_thr should be in (0, 100]' ) if items_types_weights_list.shape[0] < 0: raise Exception( 'SimVCalculator: calculate_sim_v_list: empty items_types_weights_list' ) if items_types_weights_list.shape[1] != 4: raise Exception( 'SimVCalculator: calculate_sim_v_list: incorrect items_types_weights_list' ) if np.any(items_types_weights_list < np.float32(0)): raise Exception( 'SimVCalculator: calculate_sim_v_list: items_types_weights_list contains weight < 0 (it should be >= 0)' ) # Get user's corresponding items and scores items_1, scores_1 = self._scores_data.get_user_data(user=user) # Create empty NumPy Array for similarity vectors' list sim_v_list = np.empty(shape=(items_types_weights_list.shape[0], users_area.shape[0]), dtype=np.float32) # For each user_2 in users' area for users_area_index in np.arange(users_area.shape[0]): user_2 = users_area[users_area_index] # Get user_2's corresponding items and scores items_2, scores_2 = self._scores_data.get_user_data(user=user_2) # To find items, which are scored by user and user_2 intersect1d, comm1, comm2 = np.intersect1d(items_1, items_2, assume_unique=False, return_indices=True) cmp_v = get_p_v(scores=scores_1[comm1], score_thr=score_thr) * get_p_v( scores=scores_2[comm2], score_thr=score_thr) # For each items_types_weights in items_types_weights_list for items_types_weights_index in np.arange( items_types_weights_list.shape[0]): items_types_weights = items_types_weights_list[ items_types_weights_index] p_weighted_scalar = np.sum( cmp_v * get_items_weights(items=intersect1d, items_types=self._items_types, items_types_weights=items_types_weights)) p_weighted_mod_1 = get_p_weighted_mod( items=items_1, items_types=self._items_types, items_types_weights=items_types_weights) p_weighted_mod_2 = get_p_weighted_mod( items=items_2, items_types=self._items_types, items_types_weights=items_types_weights) sim_v_list[items_types_weights_index, users_area_index] = p_weighted_scalar / ( p_weighted_mod_1 * p_weighted_mod_2) return sim_v_list
def main(): args = docopt(""" Usage: {} [options] Options: --unit UNIT [default: 100] --out-unit OUT_UNIT [default: 10] --font FONT [default: /usr/share/fonts/truetype/takao-gothic/TakaoExGothic.ttf] --batch-size BATCH_SIZE [default: 100] --epoch EPOCH [default: 20] --out OUT [default: result] --resume RESUME --data-size DATA_SIZE [default: 1000] --test DATA_SIZE [default: 0] """.format(sys.argv[0])) unit = int(args['--unit']) out_unit = int(args['--out-unit']) batch_size = int(args['--batch-size']) epoch = int(args['--epoch']) out = args['--out'] resume = args['--resume'] data_size = int(args['--data-size']) test_size = int(args['--test']) fonts = list(glob.glob('C:\Windows\Fonts/meiryo.ttc')) test_fonts = list(glob.glob('C:\Windows\Fonts/meiryo.ttc')) font_min = 8 font_max = 12 # create dataset candidates = '0123456789.' #ABCDEFGHIJKLMNOPQRSTUVWXYZ' print(candidates, len(candidates)) out_unit = len(candidates) gen = DataGenerator(fonts, font_min, font_max, number=data_size, candidates=candidates, displacement=1, noise=False) test_gen = DataGenerator(test_fonts, font_min, font_max, number=data_size, candidates=candidates, displacement=1, noise=False) model = MLP(font_max**2, unit, out_unit) if test_size: chainer.serializers.load_npz('./model.npz', model) N = test_size hit = 0 for x, y in [gen.get() for _ in range(N)]: v = model(np.array([x], dtype=np.float32)) _y = np.argmax(v.data) print(y, _y, v.data) if y == _y: hit += 1 img = Image.fromarray( np.int8(np.array([x], dtype=np.float32)).reshape((32, 32))) # img.show() print('HitRate: {}%'.format(hit / N * 100)) return train_iter = chainer.iterators.SerialIterator(gen, batch_size, repeat=True, shuffle=False) test_iter = chainer.iterators.SerialIterator(test_gen, batch_size, repeat=False, shuffle=False) train_model(model, train_iter, test_iter, batch_size, epoch, -1, out, resume) chainer.serializers.save_npz('./model.npz', model)
from functions.network.densenet_angio_perf import _densenet import SimpleITK as sitk eps = 1E-5 plot_tag = 'log' # densnet_unet_config = [1, 3, 3, 3, 1] # ct_cube_size = 255 # db_size1 = np.int32(ct_cube_size - 2) # db_size2 = np.int32(db_size1 / 2) # db_size3 = np.int32(db_size2 / 2) # crop_size1 = np.int32(((db_size3 - 2) * 2 + 1.0)) # crop_size2 = np.int32((crop_size1 - 2) * 2 + 1) in_dim = 101 in_size0 = (0) in_size1 = np.int8(in_dim) in_size2 = np.int8(in_size1) # conv stack in_size3 = np.int8((in_size2 - 2)) # level_design1 in_size4 = np.int8(in_size3 / 2 - 2) # downsampleing1+level_design2 in_size5 = np.int8(in_size4 / 2 - 2) # downsampleing2+level_design3 # in_size6 = int(in_size5 / 2 -2) # downsampleing2+level_design3 crop_size0 = (0) crop_size1 = np.int8(2 * in_size5 + 1) crop_size2 = np.int8(2 * crop_size1 + 1) final_layer = crop_size2 label_patchs_size = final_layer patch_window = in_dim # 89 # # in_size0 = (0) # in_size1 = (input_dim) # in_size2 = (in_size1) # conv stack
else: E -= np.log( 1 - Y[i] ) return E # list for class_0 or others, class_1 or others, and class_2 or others w_list = [] learning_rate = 0.001 l2_regularization = 0.1 # # Logistic Regression for each class # for i in range(3): # there are 3 classes in wine data class_name = 'class_' + str(i) w = np.random.randn( nXb.shape[1] ) T = np.int8( y==class_name ) z = sigmoid( nXb.dot(w) ) cost_hist = [ cross_entropy( T, z ) ] for j in range(10000): if j % 100 == 0: print( cross_entropy( T, z ) ) w -= learning_rate * ( nXb.T.dot( z - T ) - l2_regularization*w ) z = sigmoid( nXb.dot(w) ) cost_hist.append( cross_entropy( T, z ) ) w_list.append( w ) T[ y=='class_0' ] = 0 T[ y=='class_1' ] = 1 T[ y=='class_2' ] = 2 from mpl_toolkits.mplot3d import Axes3D fig = plt.figure()
def generate_train_test(ml_method, data_version, data_process, period): if ml_method == 'tsc': training_dataset = h5py.File('data_set/{}.h5'.format(data_version), 'r') elif ml_method == 'mlp': training_dataset = h5py.File('data_set/mlp_{}.h5'.format(data_version), 'r') else: raise ValueError('The data version is not recognized') x_train = training_dataset['x_{}'.format(period)][()] y_train = training_dataset['y_{}'.format(period)][()] x_test = training_dataset['x_2019'][()] y_test = training_dataset['y_2019'][()] if 'no_flux' in data_process: # remove the last 5 features x_train = x_train[..., :-5] x_test = x_test[..., :-5] if 'fusion' in data_process: y_train[y_train == 7] = 2 y_train[y_train == 9] = 2 #y_train[y_train == 8] = 0 y_train[y_train == 8] = 7 y_test[y_test == 7] = np.int8(2) y_test[y_test == 9] = np.int8(2) #y_test[y_test == 8] = np.int8(0) y_test[y_test == 8] = np.int8(7) if 'shuffle' in data_process: x_total = np.concatenate((x_train, x_test), axis=0) y_total = np.concatenate((y_train, y_test), axis=0) x_train, x_test, y_train, y_test = train_test_split(x_total, y_total, test_size=0.25, random_state=1) x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.25, random_state=1) if 'oversampling' in data_process: x_train_foreshock = x_train[y_train == 5] y_train_foreshock = y_train[y_train == 5] print(x_train_foreshock.shape) x_train = np.concatenate((x_train, x_train_foreshock)) y_train = np.concatenate((y_train, y_train_foreshock)) x_train, x_empty, y_train, y_empy = train_test_split( x_train, y_train, test_size=0.001, random_state=1) else: x_val = x_test y_val = y_test if 'minmax' in data_process: x_train_normalize = normalize_ts(x_train, x_train) x_val_normalize = normalize_ts(x_val, x_train) x_test_normalize = normalize_ts(x_test, x_train) x_train = x_train_normalize x_val = x_val_normalize x_test = x_test_normalize elif 'znorm' in data_process: x_train_normalize = standardize_ts(x_train, x_train) x_val_normalize = standardize_ts(x_val, x_train) x_test_normalize = standardize_ts(x_test, x_train) x_train = x_train_normalize x_val = x_val_normalize x_test = x_test_normalize return x_train, y_train, x_test, y_test, x_val, y_val
class A: def __float__(self) -> float: return 4.0 np.complex64(3j) np.complex64(A()) np.complex64(C()) np.complex128(3j) np.complex128(C()) np.complex128(None) np.complex64("1.2") np.complex128(b"2j") np.int8(4) np.int16(3.4) np.int32(4) np.int64(-1) np.uint8(B()) np.uint32() np.int32("1") np.int64(b"2") np.float16(A()) np.float32(16) np.float64(3.0) np.float64(None) np.float32("1") np.float16(b"2.5")