def __init__(self,
queries,
options,
scenario_plan,
samples=3):
self._queries = queries
self._samples = samples
self._options = options
self._scenario_plan = scenario_plan
self._scenarios = []
self._results = []
self._stats = []
# TODO (djrut): Implement more sophisticated scenario plans, with
# idioms such as: 'range(x..y) step z'
for scenario in scenario_plan.split(','):
self._scenarios.append(Scenario(threads=int(scenario),
samples=self._samples,
queries=self._queries,
options=self._options))
for stat_name, stat_function in stats_cfg.items():
self._stats.append(Statistic(name=stat_name,
function=stat_function))
def create_stats(self):
self.stats['po'] = Statistic('po')
self.stats['pr'] = Statistic('pr')
self.stats['ze'] = Statistic('ze')
self.stats['sp'] = Statistic('sp')
self.stats['ku'] = Statistic('ku')
self.stats['kr'] = Statistic('kr')
self.stats['pc'] = Statistic('pc')
self.stats['ji'] = Statistic('ji')
def haughTransform(img):
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 150, apertureSize=3)
lines = cv2.HoughLines(edges, 1, np.pi / 180, 200)
if lines is None:
return None
statAngle = Statistic()
angleTable = []
for i in range(lines.shape[0]):
rho, theta = lines[i][0]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
dy = y2 - y1
dx = x2 - x1
A = 0
if abs(dx) > abs(dy):
if x1 < x2:
A = 1
angle = math.atan2(-dy, dx)
else:
A = 2
angle = math.atan2(dy, dx)
else:
if y1 < y2:
A = 3
angle = math.atan2(dx, dy)
else:
A = 4
angle = math.atan2(-dx, -dy)
angleTable.append(angle)
statAngle.add(angle)
# print( dx, dy , angle * 180.0 / math.pi , A)
# reject any angle higher than 5 degree from target
targetAngle = statAngle.mean()
maxDegree = 5 * math.pi / 180
statAngle.clear()
for angle in angleTable:
if (abs(angle - targetAngle)) < maxDegree:
statAngle.add(angle)
if statAngle.count > 0:
targetAngle = statAngle.mean()
print("Best angle :", 180.0 * targetAngle / math.pi)
return targetAngle
def __init__(self):
self.FileName = FILE_NAME_EXT_DATA
self.OutputFile = None
self.LastNavigateData = None
self.DistanceFromLastPoint = 0
self.TotalDistance = 0
self.FixQuality_0 = 0;
self.FixQuality_1 = 0;
self.FixQuality_2 = 0;
self.FixQuality_3 = 0;
self.FixQuality_4 = 0;
self.FixQuality_5 = 0;
self.FixQuality_6 = 0;
self.MarkColor = None
self.PDOPList = []
self.HDOPList = []
self.VDOPList = []
self.LatitudeList = []
self.LongitudeList = []
self.AltitudeList = []
self.XList = []
self.YList = []
self.ColorList = []
self.PDOTStatistic = Statistic()
self.HDOTStatistic = Statistic()
self.VDOTStatistic = Statistic()
self.LatitudeStatistic = Statistic()
self.LongitudeStatistic = Statistic()
self.AltitudeStatistic = Statistic()
self.XStatistic = Statistic()
self.YStatistic = Statistic()
self.Basemap = None
self.CEP = 0
self.CEP95 = 0
self.CEP99 = 0
def __init__(self,feature_size):
'''
self.total_runs: the total times of making prediction
self.total_reward: the total reward of prediction
B, miu, f are median parameters
'''
self.linucb = LinUCB(feature_size)
self.lts = LTS(feature_size)
self.stat = Statistic(feature_size)
self.his_linucb = []
self.his_lts = []
self.his_stat = []
self.valid_linucb = 0
self.valid_lts = 0
self.valid_stat = 0
def __init__(self, db, chats):
self.db = db
self.chats = chats
self.updater = Updater(token=GET_TOKEN())
dispatcher = self.updater.dispatcher
dispatcher.addTelegramCommandHandler('start', self.start)
dispatcher.addTelegramCommandHandler('restrict', self.add_restrict)
dispatcher.addTelegramCommandHandler('stat', self.stats)
dispatcher.addTelegramCommandHandler('info', self.info)
dispatcher.addTelegramCommandHandler('help', self.help)
dispatcher.addTelegramCommandHandler('sites', self.sites)
dispatcher.addTelegramMessageHandler(self.answer)
self.updater.start_polling()
self.bot = telegram.Bot(token=GET_TOKEN())
self.statistician = Statistic(GET_FIRST_TIME(), GET_LAST_TIME(), db)
Bagging.__init__(self, agents)
def train(self, context, articleID, reward):
for agent in self.agents:
agent.learn(context, articleID, reward)
if __name__ == "__main__":
from LinUCB import LinUCB
from Statistic import Statistic
import Data
display, click, user_vec, pool = Data.load_from_dump()
pool_size = len(pool)
data_size = len(display)
print("pool_size= {}, data_size={}".format(pool_size, data_size))
agents = [Statistic(pool_size, Data.USER_VEC_SIZE)] # for i in range(3)]
bag = Bagging(agents)
tuning_factor = 0.001
tuning_size = int(data_size * tuning_factor)
print("tuning")
#tuning phase
for i in range(tuning_size):
bag.train(user_vec[i], display[i], click[i])
print("Predicting")
for i in range(tuning_size, data_size):
bag.predict_and_learn(user_vec[i], display[i], click[i])
#report
avg_reward = sum(bag.reward_history) * 1.0 / len(bag.reward_history)
from Statistic import Statistic # 导入Statistic类
a = Statistic('students.txt')
sum = a.statistic_sum() # 求和
print('the sum is ', sum)
ava = a.statistic_average() # 求平均值
print('the average is ', ava)
self.LinUCB_predict_and_learn(context,articleID,reward,pool)
self.lts_predict_and_learn(context,articleID,reward,pool)
self.stat_predict_and_learn(context,articleID,reward,pool)
print("==START==")
start_time = time.time()
data_dir = 'ydata-fp-td-clicks-v2_0.20111003'#'rewrite.txt'
batch_num = Data.process_large_data(data_dir)
data_gen=Data.get_batched_data(min(batch_num,3))
print("done processing data file")
agents = []
linucb=LinUCB(Data.USER_VEC_SIZE)
lts=LTS(Data.USER_VEC_SIZE)
stat = Statistic(Data.USER_VEC_SIZE)
agents.append(linucb)
agents.append(lts)
agents.append(stat)
agents=[LinUCB(Data.USER_VEC_SIZE) for i in range(3)]+[LTS(Data.USER_VEC_SIZE) for i in range(3)]+[Statistic(Data.USER_VEC_SIZE) for i in range(3)]
seprate_test = Sep_test(Data.USER_VEC_SIZE)
print("Computation starts")
total_click=0
total_data=0#count data entries
for (display,click,user_vec,pool) in data_gen:
#do something with current data
total_data+=1
total_click+=click
seprate_test.LinUCB_predict_and_learn(user_vec,display,click,pool)
def getdigitsSpacing(self, cBoxes, minSpacing):
self.digitsSpacing = 0
deltaX=[]
deltaY=[]
centerX = Statistic()
centerY = Statistic()
cx, cy = self.sudokuBoxCenter
for digit in cBoxes:
if abs(digit["center"][0] - cx) < minSpacing/2:
centerX.add(digit["center"][0])
if abs(digit["center"][1] - cy) < minSpacing/2:
centerY.add(digit["center"][0])
if centerX.count > 1:
cx = centerX.mean()
if centerY.count > 1:
cx = centerY.mean()
self.sudokuBoxCenter = (cx, cy)
#get spacing between all objects
for idx1 in range(len(cBoxes)-1):
obj1 = cBoxes[idx1]
if obj1["valid"] is False:
continue
for idx2 in range(idx1+1,len(self.allDigitsCenter)):
obj2 = cBoxes[idx2]
if obj2["valid"] is False:
continue
dx = abs(obj1["center"][0] - obj2["center"][0])
if dx >= minSpacing/2:
deltaX.append(dx)
dy = abs(obj1["center"][1] - obj2["center"][1])
if dy >= minSpacing/2:
deltaY.append(dy)
deltaX.sort()
deltaY.sort()
# now get he minimum distance
stat = Statistic()
for i in deltaX:
if stat.count == 0:
stat.add(i)
else:
if (i - stat.mean()) > minSpacing /2 :
if stat.count == 1:
stat.clear()
stat.add(i)
else:
break
spacingX = stat.mean()
stat.clear()
for i in deltaY:
if stat.count == 0:
stat.add(i)
else:
if (i - stat.mean()) > minSpacing /2 :
if stat.count == 1:
stat.clear()
stat.add(i)
else:
break
spacingY = stat.mean()
# ok we got the spacing
# we need to figure out if it is x,2x,or3x, or 4x
for i in range(1,9):
spacing = spacingX / i
if (8 * spacing) < self.sudokuBoxSize:
spacingX = spacing
break
for i in range(1,9):
spacing = spacingY / i
if (8 * spacing) < self.sudokuBoxSize:
spacingY = spacing
break
print("spacing X", spacingX,"spacingY", spacingY)
if (spacingX > 1) and ( spacingY > 1):
self.digitsSpacing = (spacingX + spacingY)/2
elif spacingX > 1:
self.digitsSpacing = spacingX
elif spacingY > 1:
self.digitsSpacing = spacingX
else:
self.digitsSpacing = self.sudokuBoxSize/9
