Esempio n. 1
0
    def createHMap(self):
        self.maporigin = (self.bounds[0], self.bounds[1])
        self.mapsize = (self.bounds[2] - self.bounds[0], self.bounds[3] - self.bounds[1])
        self.tilesize = self.maptiles[0]["ncols"]
        self.resolution = self.maptiles[0]["cellsize"]

        print("OSGB origin: " + str(self.bounds[0]) + "," + str(self.bounds[1]))
        print("Contour map size: " + str(self.mapsize[0]) + "x" + str(self.mapsize[1]))

        self.x = np.arange(0, self.mapsize[0], self.resolution)
        self.y = np.arange(0, self.mapsize[1], self.resolution)
        self.x, self.y = np.meshgrid(self.x, self.y)
        self.z = np.zeros_like(self.x, dtype=np.float)

        for tile in self.maptiles:
            ieast = int((tile["W_GB"] - self.maporigin[0]) / self.resolution)
            inorth = int((tile["S_GB"] - self.maporigin[1]) / self.resolution)
            self.z[inorth : inorth + self.tilesize, ieast : ieast + self.tilesize] = np.flipud(
                np.genfromtxt(tile["filename"], dtype=np.float, delimiter=" ", skip_header=6)
            )

        print("Read {} files".format(len(self.maptiles)))

        self.z[self.z < 0.0] = 0.0
        return self.z
Esempio n. 2
0
def relu(feature_map):
    #Preparing the output of the ReLU activation function.
    relu_out = np.zeros(feature_map.shape)
    for map_num in range(feature_map.shape[-1]):
        for r in np.arange(0,feature_map.shape[0]):
            for c in np.arange(0, feature_map.shape[1]):
                relu_out[r, c, map_num] = np.max([feature_map[r, c, map_num], 0])
    return relu_out
Esempio n. 3
0
def pooling(feature_map, size=2, stride=2):
    #Preparing the output of the pooling operation.
    pool_out = np.zeros((np.uint16((feature_map.shape[0]-size+1)/stride+1),
                            np.uint16((feature_map.shape[1]-size+1)/stride+1),
                            feature_map.shape[-1]))
    for map_num in range(feature_map.shape[-1]):
        r2 = 0
        for r in np.arange(0,feature_map.shape[0]-size+1, stride):
            c2 = 0
            for c in np.arange(0, feature_map.shape[1]-size+1, stride):
                pool_out[r2, c2, map_num] = np.max([feature_map[r:r+size,  c:c+size, map_num]])
                c2 = c2 + 1
            r2 = r2 +1
    return pool_out
Esempio n. 4
0
 def __init__(self, x, p, Nrl=1000):
     self.x = x
     self.pdf = p / p.sum()
     self.cdf = self.pdf.cumsum()
     self.inversecdfbins = Nrl
     self.Nrl = Nrl
     y = np.arange(Nrl) / float(Nrl)
     _delta = 1.0 / Nrl
     self.inversecdf = np.zeros(Nrl)
     self.inversecdf[0] = self.x[0]
     cdf_idx = 0
     for n in range(1, self.inversecdfbins):
         while self.cdf[cdf_idx] < y[n] and cdf_idx < Nrl:
             cdf_idx += 1
         # Seems a linear interpolation
         self.inversecdf[n] = (self.x[cdf_idx - 1] +
                               (self.x[cdf_idx] -
                                self.x[cdf_idx - 1]) *
                               (y[n] - self.cdf[cdf_idx - 1]) /
                               (self.cdf[cdf_idx] -
                                self.cdf[cdf_idx - 1])
                               )
         if cdf_idx >= Nrl:
             break
     self.delta_inversecdf = np.concatenate(
         (np.diff(self.inversecdf), [0])
         )
Esempio n. 5
0
    def detect(self, data):
        try:
            frame = self.bridge.imgmsg_to_cv2(data, "bgr8")
        except CvBridgeError as e:
            print(e)

        frame = imutils.resize(frame, width=400)
        cv2.imshow("Frame", frame)

        # grab the frame dimensions and convert it to a blob
        (h, w) = frame.shape[:2]
        blob = cv2.dnn.blobFromImage(cv2.resize(frame, (224, 224)), 0.007843,
                                     (224, 224), 127.5)

        # pass the blob through the network and obtain the detections and
        # predictions
        self.net.setInput(blob)
        detections = self.net.forward()

        rois = []

        # loop over the detections
        for i in np.arange(0, detections.shape[2]):
            # extract the confidence (i.e., probability) associated with
            # the prediction
            confidence = detections[0, 0, i, 2]

            # filter out weak detections by ensuring the `confidence` is
            # greater than the minimum confidence
            if confidence > self.args["confidence"]:
                # extract the index of the class label from the
                # `detections`, then compute the (x, y)-coordinates of
                # the bounding box for the object
                idx = int(detections[0, 0, i, 1])
                box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                (startX, startY, endX, endY) = box.astype("int")

                # draw the prediction on the frame
                label = "{}: {:.2f}%".format(self.CLASSES[idx],
                                             confidence * 100)
                cv2.rectangle(frame, (startX, startY), (endX, endY),
                              self.COLORS[idx], 2)
                y = startY - 15 if startY - 15 > 15 else startY + 15
                cv2.putText(frame, label, (startX, y),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, self.COLORS[idx], 2)

                if self.CLASSES[idx] is "person":
                    rois.append((startX, startY, endX, endY))

            self.pub_roi(rois)

        # show the output frame
        cv2.imshow("Frame", frame)
        #key = cv2.waitKey(1) & 0xFF
        cv2.waitKey(3)

        #Only publish if we've detected a person
        #if (len(pick) > 0):
        #    try:
        self.image_pub.publish(self.bridge.cv2_to_imgmsg(frame, "bgr8"))
def loss(T, data):
    # given a (1, 10) vector of troop positions, T, what is the expected value of winning
    # needs to account for ties better.
    prizes = np.arange(1, 11, dtype=float)
    my_score = (data < T).dot(prizes)
    opp_score = (data > T).dot(prizes)
    return (my_score > opp_score).mean()
Esempio n. 7
0
 def encode(self):
     input_text = encode_c(self.encode_text.toPlainText())
     if input_text == '':
         msgBox = QMessageBox()
         msgBox.setIcon(QMessageBox.Information)
         msgBox.setText("不能是空的")
         msgBox.setWindowTitle("系统警告")
         msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
         msgBox.buttonClicked.connect(msgButtonClick)
         returnValue = msgBox.exec()
         if returnValue == QMessageBox.Ok:
             return
     length = 35
     temp = [
         input_text[i:i + length] for i in range(0, len(input_text), length)
     ]
     for i in range(len(temp)):
         length_payload = str(format(len(temp[i]), 'b'))  # 7자리
         if len(length_payload) < 8:
             length_payload = length_payload.zfill(8)
         print(temp[i])
         total = preamble + length_payload + temp[i]
         signal = ','.join(list(total))
         time_signal = N * len(total) / sampling_rate
         t = np.arange(0, time_signal, Ts)
         np_signal = np.fromstring(signal, dtype='int', sep=',')
         sample = np.repeat(np_signal, N)
         if (len(t) % 10) != 0:
             t = t[:len(t) - 1]
         y = np.sin(2 * np.pi * (f + sample * 2000) * t)
         write('first.wav', sampling_rate, y)
         samplerate, data = sio.wavfile.read('first.wav')
         sd.play(data, samplerate)
         time.sleep(time_signal + 1)
Esempio n. 8
0
def plotHistogram(hist_count,path):
    histogram, bins = np.histogram(hist_count, bins=GRAYLEVEL)
    center = (bins[:-1] + bins[1:]) / 2
    width = 0.50
    ax = pyplot.subplot()
    ax.set_ylabel('Counts')
    ax.set_xlabel('Graylevel')
    ax.set_xticks(np.arange(0,GRAYLEVEL,30))
    ax.set_title(('Histogram'))
    ax.bar(center, histogram, width=width, color='y')
    pyplot.savefig(path)
    pyplot.clf()
Esempio n. 9
0
def conv_(img, conv_filter):
    filter_size = conv_filter.shape[1]
    result = np.zeros((img.shape))
    #Looping through the image to apply the convolution operation.
    for r in np.uint16(np.arange(filter_size/2.0, 
                          img.shape[0]-filter_size/2.0+1)):
        for c in np.uint16(np.arange(filter_size/2.0, 
                                           img.shape[1]-filter_size/2.0+1)):
            """
            Getting the current region to get multiplied with the filter.
            How to loop through the image and get the region based on 
            the image and filer sizes is the most tricky part of convolution.
            """
            curr_region = img[r-np.uint16(np.floor(filter_size/2.0)):r+np.uint16(np.ceil(filter_size/2.0)), 
                              c-np.uint16(np.floor(filter_size/2.0)):c+np.uint16(np.ceil(filter_size/2.0))]
            #Element-wise multipliplication between the current region and the filter.
            curr_result = curr_region * conv_filter
            conv_sum = np.sum(curr_result) #Summing the result of multiplication.
            result[r, c] = conv_sum #Saving the summation in the convolution layer feature map.
            
    #Clipping the outliers of the result matrix.
    final_result = result[np.uint16(filter_size/2.0):result.shape[0]-np.uint16(filter_size/2.0), 
                          np.uint16(filter_size/2.0):result.shape[1]-np.uint16(filter_size/2.0)]
    return final_result
Esempio n. 10
0
	def createHMap(self):				
		self.maporigin = (self.bounds[0],self.bounds[1])
		self.mapsize = (self.bounds[2]-self.bounds[0],self.bounds[3]-self.bounds[1])
		self.tilesize = self.maptiles[0]['ncols']
		self.resolution = self.maptiles[0]['cellsize']

		print ('OSGB origin: '+str(self.bounds[0])+','+str(self.bounds[1]))
		print ('Contour map size: '+str(self.mapsize[0])+'x'+str(self.mapsize[1]))
		
		self.x = np.arange(0, self.mapsize[0], self.resolution)
		self.y = np.arange(0, self.mapsize[1], self.resolution)
		self.x,self.y = np.meshgrid(self.x,self.y)
		self.z = np.zeros_like(self.x,dtype=np.float)
		
		for tile in self.maptiles:
			ieast = int((tile['W_GB']-self.maporigin[0])/self.resolution)
			inorth = int((tile['S_GB']-self.maporigin[1])/self.resolution)
			self.z[inorth:inorth+self.tilesize,ieast:ieast+self.tilesize] = np.flipud(np.genfromtxt(tile['filename'],dtype=np.float,delimiter=' ',skip_header=6))
			
		print ('Read {} files'.format(len(self.maptiles)))
	
		
		self.z[self.z<0.0] = 0.0
		return self.z
Esempio n. 11
0
 def test_3D(self, sc, dtype):
     a3d = np.arange(12).reshape((2, 3, 2))
     self.assertIdenticalArray(sc(a3d), np.array(a3d, dtype=dtype))
Esempio n. 12
0
 def test_2D(self, sc, dtype):
     a2d = np.arange(12).reshape((3, 4))
     self.assertIdenticalArray(sc(a2d), np.array(a2d, dtype=dtype))
Esempio n. 13
0
 def test_2D(self, sc, dtype):
     a2d = np.arange(12).reshape((3,4))
     self.assertIdenticalArray(sc(a2d), np.array(a2d, dtype=dtype))                                  
Esempio n. 14
0
import operator
import csv
import math
form_class = uic.loadUiType("gui_for_translate.ui")[0]

sampling_rate = 48000
symbol_duration = 0.025
f = 4000
N = sampling_rate * symbol_duration
Ts = 1 / sampling_rate
FILENAME = "tmp.wav"
preamble = '01010101010101010101'

preamble_signal = ','.join(list(preamble))
preamble_time_signal = N * len(preamble) / sampling_rate
preamble_t = np.arange(0, preamble_time_signal, Ts)
preamble_np_signal = np.fromstring(preamble_signal, dtype='int', sep=',')
preamble_sample = np.repeat(preamble_np_signal, N)
preamble_y = np.sin(2 * np.pi * (f + preamble_sample * 2000) * preamble_t)


def encode_c(s):
    return ''.join([bin(ord(c)).replace('0b', '') for c in s])


def decode_c(s):
    return ''.join([chr(i) for i in [int(b, 2) for b in s.split(' ')]])


class ThreadClass(QThread):
    def __init__(self):
#Function to compute the mean of absolute values of non-diagonal elements
def meanNonDiag(whitenedMatrix):

    whitenedCov = np.abs(np.cov(whitenedMatrix))
    sumNonDiag = np.sum(whitenedCov) - np.trace(whitenedCov)
    n = whitenedCov.shape[0]
    return sumNonDiag / (n * n - n)


meanNonDiagCleanFromClean = meanNonDiag(YCleanFromClean)
meanNonDiagNoisyFromClean = meanNonDiag(YNoisyFromClean)
meanNonDiagNoisyFromNoisy = meanNonDiag(YNoisyFromNoisy)
meanNonDiagCleanFromNoisy = meanNonDiag(YCleanFromNoisy)

freq = np.arange(1, 129)
"""
# Spectrograms for (a)
figure, axes = plt.subplots(2, 2)

axes[0,0].pcolor(timeClean, freq, specClean)
axes[0,0].set(xlabel='Time', ylabel='Frequency')
axes[0,0].set_title('Original Clean Spectrogram')

axes[1,0].pcolor(timeClean, freq, YCleanFromClean)
axes[1,0].set(xlabel='Time', ylabel='Frequency')
axes[1,0].set_title('Clean Whitened using Clean')

axes[0,1].pcolor(timeNoisy, freq, specNoisy)
axes[0,1].set(xlabel='Time', ylabel='Frequency')
axes[0,1].set_title('Original Noisy Spectrogram')
Esempio n. 16
0
 def test_2D(self, sc, dtype):
     a2d = np.arange(12).reshape((3, 4))
     self.assertIdenticalArray(
         sc[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]],
         np.array(a2d, dtype=dtype))
Esempio n. 17
0
 def test_2D(self):
     a2d = np.arange(12).reshape((3, 4))
     self.assertIdenticalArray(np(a2d), np.array(a2d))
Esempio n. 18
0
# 2Write a NumPy program to compute the determinant of an array
x = np.array([[1, 2], [3, 4]])
print("original arr:")
print(x)
result = np.linalg.det(x)
print("determinant:")
print(result, '\n')

# 3 Write a NumPy program to compute the sum of the diagonal element of a given array
x = np.array([[2, 4, 5], [8, 9, 10], [12, 15, 16]])
print(x, "matrix:")
diag = np.diagonal(x)
print("\nDiagonal matrix:")
print(diag)
print("\nSum of diagonal matrix:")
print(sum(diag))

# 4Write a NumPy program to compute the inverse of a given matrix
x = np.array([[1, 2], [3, 4]])
print("original matrix:")
print(x)
result = np.linalg.inv(x)
print("inverse matrix:")
print(result, "\n")

#5Write a NumPy program to generate matrix and write it to a file, then again read from file that matrix.
x = np.arange(15)
np.save('another_x', x)
read_file_info = np.load('another_x.npy')
print(read_file_info)
Esempio n. 19
0
data = StingIO("1 2 3\n 4 5 6")
data = StringIO("1 2 3\n 4 5 6")
np.genfromtxt(data,dtypr=(int,float,int))
np.genfromtxt(data,dtype=(int,float,int))
convertfunc = lambda x: float(x.strip(b"%"))/100.
data = u"1,2.3%,45.\n6,78.9%,0"
np.genfromtxt(StringIO(data),delimiter='',names=names,converters={1:convertfunc})
names = ['a','b','c']
np.genfromtxt(StringIO(data),delimiter='',names=names,converters={1:convertfunc})
data = u"N/A, 2, 3\n4,,???"
kwargs = dict(delimiter=',',dtype=int,names='a,b,c',missing_values={0:"N"})
kwargs = dict(delimiter=',',dtype=int,names='a,b,c',missing_values={0:"N/A",'b':0,2:"???"},filling_values={0:0,'b':0,2:-999})
np.gemfromtxt(SringIO(data),**kwargs)
np.genfromtxt(SringIO(data),**kwargs)
np.genfromtxt(StringIO(data),**kwargs)
x = np.arange(10,1,-1)
x
y = np.linspace(1,19,4)
y
x[np.array([3,3,1,8])]
z = x[np.array([3,3,1,8])]
z.base
z.base()
y = x
y.base
y.base()
np.base(y)
x.base
z.flags.owndata
y.flags.owndata
x.flags.owndata
Esempio n. 20
0
 def test_3D(self):
     a3d = np.arange(12).reshape((2,3,2))
     self.assertIdenticalArray(np(a3d), np.array(a3d))
Esempio n. 21
0
 def test_2D(self):
     a2d = np.arange(12).reshape((3,4))
     self.assertIdenticalArray(np(a2d), np.array(a2d))                                  
Esempio n. 22
0
 def test_3D(self):
     a3d = np.arange(12).reshape((2,3,2))
     self.assertIdenticalArray(np[[[ 0,  1], [ 2,  3], [ 4,  5]],
                                  [[ 6,  7], [ 8,  9], [10, 11]]],
                               np.array(a3d))
Esempio n. 23
0
 def test_2D(self):
     a2d = np.arange(12).reshape((3,4))
     self.assertIdenticalArray(np[[0,1,2,3],[4,5,6,7],[8,9,10,11]],
                               np.array(a2d))                         
Esempio n. 24
0
 def test_3D(self, sc, dtype):
     a3d = np.arange(12).reshape((2,3,2))
     self.assertIdenticalArray(sc(a3d), np.array(a3d, dtype=dtype))
Esempio n. 25
0
 def test_2D(self):
     a2d = np.arange(12).reshape((3, 4))
     self.assertIdenticalArray(
         np[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]], np.array(a2d))
Esempio n. 26
0
 def test_3D(self):
     a3d = np.arange(12).reshape((2, 3, 2))
     self.assertIdenticalArray(
         np[[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]],
         np.array(a3d))
Esempio n. 27
0
    1595151900,
    1595151960,
])

#设置相似度
y = np.array([
    0.8579087793827057, 0.8079087793827057, 0.9679087793827057,
    0.679087793827057, 0.5579087793827057, 0.9579087793827057,
    0.3079087793827057, 0.3009087793827057, 0.2579087793827057,
    0.2009087793827057, -0.1999087793827057, 0.9579087793827057,
    0.0099087793827057, 0.0079087793827057, 0.0069087793827057,
    0.0019087793827057, 0.0000087793827057
])

#插值法之后的x轴值,表示从0到10间距为0.5的200个数
xnew = np.arange(1595151000, 1595151960, 0.1)

#实现函数
func = interpolate.interp1d(x, y, kind='cubic')

#利用xnew和func函数生成ynew,xnew数量等于ynew数量
ynew = func(xnew)

# 原始折线
plt.plot(x, y, "r", linewidth=1)

#平滑处理后曲线
plt.plot(xnew, ynew)
#设置x,y轴代表意思
plt.xlabel("The distance between POI  and user(km)")
plt.ylabel("probability")
Esempio n. 28
0
 def test_3D(self):
     a3d = np.arange(12).reshape((2, 3, 2))
     self.assertIdenticalArray(np(a3d), np.array(a3d))
Esempio n. 29
0
    detector_shape = (2048, 2048)
    pixel_area = detector_shape
    detector_area = (plate_scale ** 2 * detector_shape[0] *
                     detector_shape[1]) / 3600.

    nstars = int(round(detector_area * (scmodel.integral_counts(magmax) -
                                        scmodel.integral_counts(magmin))))
    print('nstars', nstars)

    seeing = 1.0

    scale = 2 * sqrt(2 * log(2))

    delta = 0.1
    steps = int(round((magmax - magmin) / delta))
    x = magmin + delta * np.arange(steps)
    p = np.array([scmodel.differential_counts(i) for i in x])

    g = GeneralRandom(x, p)

    mags = g.random(nstars)
    y = np.random.uniform(high=pixel_area[0], size=nstars)
    x = np.random.uniform(high=pixel_area[1], size=nstars)

    np.random.seed(100)
    x = np.random.uniform(high=2048, size=nstars)
    y = np.random.uniform(high=2048, size=nstars)
    sigmas = [seeing / scale / plate_scale] * nstars
    ints = [100] * nstars
    mag = g.random(N=nstars)
Esempio n. 30
0
 def test_3D(self, sc, dtype):
     a3d = np.arange(12).reshape((2, 3, 2))
     self.assertIdenticalArray(
         sc[[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]],
         np.array(a3d, dtype=dtype))
Esempio n. 31
0
 def test_2D(self, sc, dtype):
     a2d = np.arange(12).reshape((3,4))
     self.assertIdenticalArray(sc[[0,1,2,3],[4,5,6,7],[8,9,10,11]],
                               np.array(a2d, dtype=dtype))
import os
import asyncio
import datetime
import random
import functools
import websockets
import np
from http import HTTPStatus

MIME_TYPES = {"html": "text/html", "js": "text/javascript", "css": "text/css"}

sampling_rate = 1000
freq = 5
samples = 1000
x = np.arange(samples)
y = 100 * np.sin(2 * np.pi * freq * x / sampling_rate)


# print(y)
async def process_request(path, request_headers):
    """Serves a file when doing a GET request with a valid path."""

    if "Upgrade" in request_headers:
        return  # Probably a WebSocket connection

    if path == '/':
        path = '/index.html'

    response_headers = [
        ('Server', 'asyncio websocket server'),
        ('Connection', 'close'),
Esempio n. 33
0
    infile.close()
    return n_flows, cardinality, flow_set_coverage, heavy_hitter_detection_f1_score, heavy_hitter_are, flow_size_estimation


if __name__ == "__main__":
    hf_n_flows, hf_cardinality, hf_flowset_coverage, hf_heavy_hitter_detection_f1_score, hf_heavy_hitter_are, hf_flow_size_estimation, = parse_file(
        "./HashFlow.txt")
    hp_n_flows, hp_cardinality, hp_flowset_coverage, hp_heavy_hitter_detection_f1_score, hp_heavy_hitter_are, hp_flow_size_estimation, = parse_file(
        "./HashPipe.txt")
    es_n_flows, es_cardinality, es_flowset_coverage, es_heavy_hitter_detection_f1_score, es_heavy_hitter_are, es_flow_size_estimation, = parse_file(
        "./ElasticSketch.txt")
    fr_n_flows, fr_cardinality, fr_flowset_coverage, fr_heavy_hitter_detection_f1_score, fr_heavy_hitter_are, fr_flow_size_estimation, = parse_file(
        "./FlowRadar.txt")

    plt.figure(1)
    plt.xticks(np.arange(0, 250001, 50000),
               ("0", "50K", "100K", "150K", "200K", "250K"))
    plt.plot(hf_n_flows,
             hf_flow_size_estimation,
             label="HashFlow",
             marker="x",
             markersize=10)
    plt.plot(hp_n_flows,
             hp_flow_size_estimation,
             label="HashPipe",
             marker="^",
             markersize=10)
    plt.plot(es_n_flows,
             es_flow_size_estimation,
             label="ElasticSketch",
             marker="<",
Esempio n. 34
0
def gaussian_kernel_1d(sigma):
    kernel_radius = np.ceil(sigma) * 3
    kernel_size = kernel_radius * 2 + 1
    ax = np.arange(-kernel_radius, kernel_radius + 1., dtype=np.float32)
    kernel = np.exp(-(ax**2) / (2. * sigma**2))
    return (kernel / np.sum(kernel)).reshape(1, kernel.shape[0])
Esempio n. 35
0
 def test_3D(self, sc, dtype):
     a3d = np.arange(12).reshape((2,3,2))
     self.assertIdenticalArray(sc[[[ 0,  1], [ 2,  3], [ 4,  5]],
                                  [[ 6,  7], [ 8,  9], [10, 11]]],
                               np.array(a3d, dtype=dtype))
Esempio n. 36
0
x_data = [10, 15, 20, 22.5]  #second
y_data = [2278.04, 362.78, 517.35, 602.78]


def forward(x):
    return x * w


def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) * (y_pred - y)


mse_list = []
w_list = []
for w in np.arange(10, 22.5, 2.4):
    print("w=", w)
    l_sum = 0.0
    for x_val, y_val in zip(x_data, y_data):
        y_pred_val = forward(x_val)
        l = loss(x_val, y_val)
        l_sum += l
        print("\t", x_val, y_val, y_pred_val, l)

    print("MSE=", l_sum / 3)
    w_list.append(w)
    mse_list.append(l_sum / 3)

plt.plot(w_list, mse_list)
plt.ylabel("Loss")
plt.xlabel("w")
Esempio n. 37
0
    infile.close()
    return n_flows, cardinality, flow_set_coverage, heavy_hitter_f1_score, heavy_hitter_are, flow_size_estimation


if __name__ == "__main__":
    basic_n_flows, basic_cardinality, basic_flowset_coverage, basic_heavy_hitter_f1_score, basic_heavy_hitter_are, basic_flow_size_estimation = parse_file(
        "./result_basic_hashflow_84454.txt")
    _06_n_flows, _06_cardinality, _06_flowset_coverage, _06_heavy_hitter_f1_score, _06_heavy_hitter_are, _06_flow_size_estimation = parse_file(
        "./result_06_hashflow_84454.txt")
    _07_n_flows, _07_cardinality, _07_flowset_coverage, _07_heavy_hitter_f1_score, _07_heavy_hitter_are, _07_flow_size_estimation = parse_file(
        "./result_07_hashflow_84454.txt")
    _08_n_flows, _08_cardinality, _08_flowset_coverage, _08_heavy_hitter_f1_score, _08_heavy_hitter_are, _08_flow_size_estimation = parse_file(
        "./result_08_hashflow_84454.txt")

    plt.figure(1)
    plt.xticks(np.arange(0, 60001, 10000),
               ("0", "10K", "20K", "30K", "40K", "50K", "60K"))
    plt.plot(basic_n_flows[0:6],
             basic_flow_size_estimation[0:6],
             label="Multi-hash",
             marker="x",
             markerfacecolor="none",
             markersize=markersize,
             color="blue")
    plt.plot(_06_n_flows[0:6],
             _06_flow_size_estimation[0:6],
             label=r"$\alpha$=0.6",
             marker="^",
             markerfacecolor="none",
             markersize=markersize,
             color="red")
Esempio n. 38
0
z = hdata.createHMap()

np.savetxt("foo.csv", z, delimiter=",")

#Define contour levels
hlims = [np.amin(z), np.amax(z)]
hrange = np.ptp(z)
cint = max(PREF_INTERVALS)
layers = int(np.ceil(hrange/cint))
for try_i in PREF_INTERVALS:
	try_layers = int(np.ceil(hrange/try_i))
	if try_layers > layers and try_layers < DEF_MAX_LAYERS:
		cint = try_i
		layers = try_layers
print('{} layers. {}m interval'.format(layers,cint))
cheights = np.arange(np.floor(hlims[0]/cint)*cint, np.ceil(hlims[1]/cint)*cint, cint)

#Generate contours
contourdata = cntr.Cntr(hdata.x, hdata.y, z)

cvs = pyx.canvas.canvas()
cvs.text(0, 0, "Hello, world!")
cvs.stroke(pyx.path.line(0, 0, 2, 0))

for cheight in cheights:
	clist = contourdata.trace(cheight, cheight, 0)
	clist = clist[:len(clist)//2]
	print('Level {}m, {} contours'.format(cheight,len(clist)))
	for contour in clist:
		contour = contour*SCALE
		path = [pyx.path.moveto(*contour[0])] + [pyx.path.lineto(*c) for c in contour[1:]]
Esempio n. 39
0
    def query(self, n, model, train_dataset, pool_dataset, budget=10000):
        device = model.state_dict()['softmax.bias'].device

        full_dataset = ConcatDataset([pool_dataset, train_dataset])
        pool_len = len(pool_dataset)

        self.embeddings = self.get_embeddings(model, device, full_dataset)

        # Calc distance matrix
        num_images = self.embeddings.shape[0]
        dist_mat = self.calc_distance_matrix(num_images)

        # We need to get k centers start with greedy solution
        upper_bound = gb.UB
        lower_bound = upper_bound / 2.0
        max_dist = upper_bound

        _x, _y = np.where(dist_mat <= max_dist)
        _distances = dist_mat[_x, _y]
        subset = [i for i in range(1)]
        model = solve_fac_loc(_x, _y, subset, num_images, budget)
        # model.setParam( 'OutputFlag', False )
        x, y, z = model.__data
        delta = 1e-7

        while upper_bound - lower_bound > delta:
            print("State", upper_bound, lower_bound)
            current_radius = (upper_bound + lower_bound) / 2.0

            violate = np.where(_distances > current_radius)  # Point distances which violate the radius

            new_max_d = np.min(_distances[_distances >= current_radius])
            new_min_d = np.max(_distances[_distances <= current_radius])

            print("If it succeeds, new max is:", new_max_d, new_min_d)

            for v in violate[0]:
                x[_x[v], _y[v]].UB = 0  # The upper bound for points, which violate the radius are set to zero

            model.update()
            r = model.optimize()

            if model.getAttr(gb.GRB.Attr.Status) == gb.GRB.INFEASIBLE:
                failed = True
                print("Infeasible")
            elif sum([z[i].X for i in range(len(z))]) > 0:
                failed = True
                print("Failed")
            else:
                failed = False

            if failed:
                lower_bound = max(current_radius, new_max_d)
                # failed so put edges back
                for v in violate[0]:
                    x[_x[v], _y[v]].UB = 1
            else:
                print("solution found", current_radius, lower_bound, upper_bound)
                upper_bound = min(current_radius, new_min_d)
                model.write("s_{}_solution_{}.sol".format(budget, current_radius))

        idxs_labeled = np.arange(start=pool_len, stop=pool_len + len(train_dataset))

        # Perform kcenter greedy
        self.update_distances(idxs_labeled, idxs_labeled, only_new=False, reset_dist=True)
        sel_ind = []
        for _ in range(n):
            ind = np.argmax(self.min_distances)  # Get sample with highest distance
            assert ind not in idxs_labeled, "Core-set picked index already labeled"
            self.update_distances([ind], idxs_labeled, only_new=True, reset_dist=False)
            sel_ind.append(ind)

        assert len(set(sel_ind)) == len(sel_ind), "Core-set picked duplicate samples"

        remaining_ind = list(set(np.arange(pool_len)) - set(sel_ind))

        return sel_ind, remaining_ind
Esempio n. 40
0
np.savetxt("foo.csv", z, delimiter=",")

#Define contour levels
hlims = [np.amin(z), np.amax(z)]
hrange = np.ptp(z)
cint = max(PREF_INTERVALS)
layers = int(np.ceil(hrange / cint))
for try_i in PREF_INTERVALS:
    try_layers = int(np.ceil(hrange / try_i))
    if try_layers > layers and try_layers < DEF_MAX_LAYERS:
        cint = try_i
        layers = try_layers
print('{} layers. {}m interval'.format(layers, cint))
cheights = np.arange(
    np.floor(hlims[0] / cint) * cint,
    np.ceil(hlims[1] / cint) * cint, cint)

#Generate contours
contourdata = cntr.Cntr(hdata.x, hdata.y, z)

cvs = pyx.canvas.canvas()
cvs.text(0, 0, "Hello, world!")
cvs.stroke(pyx.path.line(0, 0, 2, 0))

for cheight in cheights:
    clist = contourdata.trace(cheight, cheight, 0)
    clist = clist[:len(clist) // 2]
    print('Level {}m, {} contours'.format(cheight, len(clist)))
    for contour in clist:
        contour = contour * SCALE
Esempio n. 41
0
#https://matplotlib.org/tutorials/introductory/pyplot.html

import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter  # useful for `logit` scale
import np

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the interval ]0, 1[
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure(1)

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)

# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)