def test_string_representation(self):
self.assertEqual(
repr(Comparator(5, delta=0.1)),
"Comparator(5, delta=0.1)",
)
self.assertEqual(repr(Comparator(5)), "Comparator(5, delta=1e-07)")
self.assertEqual(str(Comparator(5)), "Comparator(5, delta=1e-07)")
def test_arithmetic_and_comparisons_with_comparators(self):
five = Comparator(5, delta=0.1)
six = Comparator(6, delta=0.1)
seven = Comparator(7, delta=0.5)
self.assertEqual(five + six, 11.1)
self.assertNotEqual(five + six, 11.2)
self.assertEqual(five + seven, 12.1)
self.assertEqual(five + seven, 12.5)
self.assertEqual(seven + five, 12.5)
self.assertNotEqual(five + seven, 12.6)
def test_default_delta_context_manager(self):
with Comparator.default_delta(0.5):
self.assertEqual(Comparator(5), 5.5)
self.assertNotEqual(Comparator(5), 5.6)
self.assertNotEqual(Comparator(5, delta=0.1), 5.5)
self.assertNotEqual(Comparator(5), 5.5)
try:
with Comparator.default_delta(0.5):
raise ValueError
except ValueError:
pass
self.assertNotEqual(Comparator(5), 5.5)
def test_addition_and_subtraction(self):
self.assertEqual(Comparator(5, delta=0.1) + 6, 11.1)
self.assertEqual(6 + Comparator(5, delta=0.1), 10.9)
self.assertNotEqual(Comparator(5, delta=0.1) + 6, 11.2)
self.assertNotEqual(6 + Comparator(5, delta=0.1) + 6, 10.8)
self.assertEqual(Comparator(7, delta=0.1) - 6, 1.05)
self.assertNotEqual(Comparator(7, delta=0.1) - 6, 1.2)
self.assertEqual(7 - Comparator(7, delta=0.1), 0.05)
self.assertNotEqual(7 - Comparator(7, delta=0.1), 0.11)
self.assertEqual(6 - Comparator(7, delta=0.1), -1.05)
def __init__(self, server):
self.server = server
self.deck = createCards()
self.table = []
self.clients = []
self.comparator = Comparator()
self.rise_client = None
def detect_single(self, img, mask):
thresholds = [0.4] * 7
thresholds[1] = 0.7
thresholds[2] = 0.3
labels, self.nodes = img_to_nodes(img, mask)
self.comparator = Comparator(self.nodes, labels)
res = []
for dots in range(6, 0, -1):
matches = []
for node in tqdm(self.nodes.values()):
matches.append(self.detect_with_node(node, dots))
matches.sort(key=itemgetter(0))
for m in matches:
if m[0] > thresholds[dots]:
break
vis = False
for n in m[1]:
if n.visited:
vis = True
if vis:
continue
pattern = self.comparator.get_pattern(m[1], dots)
res.append((find_contours(pattern, 0.5)[0], dots))
print(m[0])
for n in m[2]:
print(n.a, end=' ')
n.visited = True
print(' ')
return res
def __init__(self, number_of_gaussian):
self.ng = number_of_gaussian
self.gmm = GMM(number_of_gaussian)
self.comparator_with_impostor = ComparatorWithImpostor(
number_of_gaussian)
self.comparator = Comparator(number_of_gaussian)
self.cross_validator = CrossValidation(0.3)
def onClicked_CreateNewComparator(self):
toAddUids = self.qMainTreev.getSelectedItemUids()
if toAddUids:
comp = Comparator()
for uid in toAddUids:
entry = self.compTableModel.ADB.getEntryByUid(uid)
comp.addEntry(entry)
self.addTab1_new(comp)
def __init__(self, server):
self.server = server
self.deck = createCards()
self.table = []
self.clients = []
self.comparator = Comparator()
self.rise_client = None
self.bet = 0
self.bank = 0
self.big_blind = 100
def create(scripts_processor: "ScriptSetProcessor",
directive_provider: DirectiveProvider, python_version: str,
source_script: SourceScript):
comparator = Comparator({'python_version': python_version})
def local_is_true(args: List[str]):
return comparator.check(args[0], args[1], args[2])
branch_processor = BranchProcessor(local_is_true)
return DirectiveProcessor(scripts_processor, branch_processor,
directive_provider)
def test_equality_with_default_delta(self):
self.assertEqual(Comparator(5), 4.99999999)
self.assertEqual(Comparator(5), 5.00000001)
self.assertEqual(5, Comparator(4.99999999))
self.assertEqual(5, Comparator(5.00000001))
self.assertNotEqual(Comparator(5), 4.99999)
self.assertNotEqual(Comparator(5), 5.00001)
def setComparatorToShow(self, cp):
if cp:
self.comp = Comparator() # The one to be modified
self.originalComp = cp # The pointer to the original Comparator
self.comp.updateFromGiven(cp)
srcModel = SourceArticleDBModel(self.comp)
self.qCompViewer.setSourceModel(srcModel)
self.qCompViewer.loadHeaderState()
self.compNameLineEdit.setText(self.comp.name)
self.compCommentText.setPlainText(self.comp.comment)
def detect_objects():
global previous_objects, appLogger
detector = Detector()
comp = Comparator(detector)
while True:
detected_objects = detector.process_next_frame()
print("[Detection Stage] Done")
if not previous_objects:
previous_objects = detected_objects
else:
print("[Looking for changes - Tracking Stage]")
print(
comp.compare_objects_lists(previous_objects, detected_objects))
previous_objects = detected_objects
detector.show_frame()
time.sleep(DELAY)
def onClicked_SaveComparator_New(self):
currentCTab = self.tabWidget.currentWidget()
name = currentCTab.compNameLineEdit.text()
if not self.validateComparatorName():
return
currentCTab.comp.setName(currentCTab.compNameLineEdit.text())
currentCTab.comp.setComment(currentCTab.compCommentText.toPlainText())
if currentCTab.originalComp is None:
print("Create comparator ", name)
currentCTab.originalComp = Comparator()
currentCTab.originalComp.updateFromGiven(currentCTab.comp)
self.compTableModel.addComparator(currentCTab.originalComp)
else:
print("Update comparator ", name)
currentCTab.originalComp.updateFromGiven(currentCTab.comp)
self.compTableModel.emitAllDataChanged()
def bmh_matcher(t,p):
table = make_table(p)
c = Comparator()
results = []
i = 0
while i < len(t):
try:
first = t[i+len(p)]
except IndexError:
return results, c
for j in range(len(p)-1,-1,-1):
if not c.compare(p,j,t,i+j):
i += table[first]
break
elif j == 0:
results.append(i)
i+=table[first]
return results, c
def test_1():
ref_file = open('./tests/data/input/optimization1.out.json',
'r',
encoding="utf-8")
comp_file = open('./tests/data/input/optimization2.out.json',
'r',
encoding="utf-8")
ref_content = json.loads(ref_file.read())
comp_content = json.loads(comp_file.read())
ref_file.close()
comp_file.close()
comp = Comparator(ref_content, comp_content)
comp_results = comp.compare()
assert isinstance(comp_results, List)
assert len(comp_results) == 3
# First result
res = comp_results[0]
assert isinstance(res, TestResult)
assert res.file_path == '/home/evaluation/evaluation/pub/bench/lorem/ipsum/1'
exit_diff = res.exit_diff
assert isinstance(exit_diff, Diff)
assert exit_diff.label == 'Exit value'
assert exit_diff.reference == 4
assert exit_diff.value == 2
assert exit_diff.diff == -2
assert exit_diff.variation == -50
diffs = res.diffs
assert isinstance(diffs, List)
assert len(diffs) == 2
diff_bound = diffs[0]
assert diff_bound.label == 'bound'
assert diff_bound.reference == 12
assert diff_bound.value == 12
assert diff_bound.diff == 0
assert diff_bound.variation == 0
diff_time = diffs[1]
assert diff_time.label == 'time'
assert diff_time.reference == 2
assert diff_time.value == 1
assert diff_time.diff == -1
assert diff_time.variation == -50
def addTab1_Append(self):
if len(self.compTableView.view.selectedIndexes()) < 1:
return
original = self.compTableView.view.selectedIndexes(
)[0].internalPointer()
uids = self.qMainTreev.getSelectedItemUids()
if not uids:
return
tabIndex = self.checkIfCompOpened(original.name)
if tabIndex > 0:
tgtTab = self.tabWidget.widget(tabIndex)
for uid in uids:
entry = self.compTableModel.ADB.getEntryByUid(uid)
tgtTab.qCompViewer.proxyModel.sourceModel().appendItem(entry)
self.tabWidget.setCurrentIndex(tabIndex)
return
theComp = Comparator()
theComp.updateFromGiven(original)
for uid in uids:
entry = self.compTableModel.ADB.getEntryByUid(uid)
theComp.addEntry(entry)
tab = ComparatorTabPageWidget()
tab.setComparatorToShow(theComp)
tab.originalComp = original
newidx = self.tabWidget.addTab(
tab, theComp.name[:16]
if len(theComp.name) < 16 else theComp.name[:13] + "..")
self.tabWidget.setCurrentIndex(newidx)
tab.btnCancel.clicked.connect(self.closeCurrentTab)
tab.btnSave.clicked.connect(self.onClicked_SaveComparator_OpenAppend)
tab.qCompViewer.proxyView.doubleClicked.connect(
self.onDoubleClicked_EditCompEntry)
tab.compNameLineEdit.textChanged.connect(
self.setCurrentComparatorTabLabel)
self.setCurrentComparatorTabLabel()
def test_simple_check(self):
c = Comparator()
self.assertFalse(c.check("2.0", "<", "2.0"))
self.assertTrue(c.check("2.0", "<=", "2.0"))
self.assertTrue(c.check("2.0", "==", "2.0"))
self.assertTrue(c.check("2.0", ">=", "2.0"))
self.assertFalse(c.check("2.0", ">", "2.0"))
self.assertTrue(c.check("2.0", "<", "2.1"))
self.assertTrue(c.check("2.0", "<=", "2.1"))
self.assertFalse(c.check("2.0", "==", "2.1"))
self.assertFalse(c.check("2.0", ">=", "2.1"))
self.assertFalse(c.check("2.0", ">", "2.1"))
self.assertFalse(c.check("2.1", "<", "2.0"))
self.assertFalse(c.check("2.1", "<=", "2.0"))
self.assertFalse(c.check("2.1", "==", "2.0"))
self.assertTrue(c.check("2.1", ">=", "2.0"))
self.assertTrue(c.check("2.1", ">", "2.0"))
def kmp_match(t, p):
'''
Find all instances of p in t, runs a comparator class that keeps track of the number of comparisons made
'''
pi = compute_prefix(p)
q = 0 #number of thus far matched characters in the pattern
c = Comparator()
results = []
for i in range(0, len(t)):
# we've matched some characters, but not enough, so we shift forward by the prefix amount
while q > 0 and not c.compare(p, q, t, i):
q = pi[q]
# we've matched another character
if c.compare(p, q, t, i):
q += 1
# we've matched as many chars are there in the pattern, we've found a match
if q == len(p):
results.append(i - len(p) + 1)
q = pi[q - 1]
return results, c
def main():
if len(sys.argv) < 2:
print("Usage: " + sys.argv[0] + " <board>")
return
board = sys.argv[1]
posts = {}
try:
posts = json.loads(open("data/posts_%s.json" % board).read())
except Exception as e:
pass
regexps_like = [
regex.split("\n")[0]
for regex in open("data/regexps_like").readlines()
]
regexps_dislike = [
regex.split("\n")[0]
for regex in open("data/regexps_dislike").readlines()
]
comparator_dislike = Comparator(
open("data/comparator.wasm", "rb").read(), [
base64.b64decode(image.split("\n")[0])
for image in open("data/images").readlines()
])
checker = Checker(regexps_like, regexps_dislike, comparator_dislike)
proxies = Proxies(
[proxy.split("\n")[0] for proxy in open("data/proxies").readlines()])
network = Network(proxies, 10)
liker = Liker(board, checker, posts, network)
network.start()
network.join()
import sys
from comparator import Comparator
if __name__ == "__main__":
args = sys.argv
if len(args) != 3:
print('incorrect args')
sys.exit(0)
comparator = Comparator()
degree = comparator.compare(sys.argv[1], sys.argv[2])
sys.stdout.write(str(degree))
sys.exit(0)
phones = self.get_models(brand)
self.phones.extend(phones)
print "-------------"
print "Finished crawling all phones. Total number = " + str(
len(self.phones))
return self.phones
if __name__ == "__main__":
script_loc = os.path.dirname(os.path.realpath(__file__))
os.chdir(script_loc)
scrapper = Scrapper()
phones = scrapper.build_knowledge_base()
if os.path.isfile("save.p"):
old_phones = pickle.load(open("save.p", "rb"))
comparator = Comparator(old_phones, phones)
new_phones = comparator.get_new_phones()
removed_phones = comparator.get_removed_phones()
updated_phones = comparator.get_updated_phones()
# Dumping the new data to the disk
print "Storing today's data to disk .."
pickle.dump(phones, open("save.p", "wb"))
# Sending mail results
print "Sending mail results .."
reporter = Report(phones, new_phones, removed_phones, updated_phones)
reporter.send_updates()
def __init__(self):
super(ComparatorTabPageWidget, self).__init__()
hbox = QHBoxLayout()
gbox = QGridLayout()
# Deal with the side bar
leftFrame = QFrame()
leftFrame.setFrameShape(QFrame.StyledPanel)
leftFrame.setMinimumSize(200, 600)
leftFrame.setMaximumWidth(300) # Max width
leftFrame.setLayout(gbox)
compNameLabel = QtWidgets.QLabel("&Comparator Name:")
self.compNameLineEdit = QtWidgets.QLineEdit()
self.compNameLineEdit.setMaxLength(32)
compNameLabel.setBuddy(self.compNameLineEdit)
gbox.addWidget(compNameLabel, 0, 0, 1, 2)
gbox.addWidget(self.compNameLineEdit, 1, 0, 1, 2)
compCommentLabel = QtWidgets.QLabel("My Comment:")
self.compCommentText = QPlainTextEdit()
self.compCommentText.setTabChangesFocus(True)
compNameLabel.setBuddy(self.compCommentText)
gbox.addWidget(compCommentLabel, 2, 0, 1, 2)
gbox.addWidget(self.compCommentText, 3, 0, 1, 2)
groupFilter = QGroupBox("Entry Filter", leftFrame)
groupFilter.setMaximumHeight(250)
groupGridLayout = QGridLayout()
groupFilter.setLayout(groupGridLayout)
self.filterCaseSensitivityCheckBox = QtWidgets.QCheckBox("Case sensitive")
self.filterCaseSensitivityCheckBox.setChecked(False)
self.filterSyntaxCheckBox = QtWidgets.QCheckBox("Use Regex")
self.filterSyntaxCheckBox.setChecked(True)
self.filterPatternLineEdit = QtWidgets.QLineEdit()
self.filterDomainCombo = QtWidgets.QComboBox()
self.filterDomainCombo.addItem("All", searchableDomainIndex)
for i in searchableDomainIndex:
self.filterDomainCombo.addItem(headerNames[i], [i])
filterComboLabel = QtWidgets.QLabel("Filter Domain:")
filterComboLabel.setBuddy(self.filterDomainCombo)
groupGridLayout.addWidget(filterComboLabel, 0, 0, 1, 4)
groupGridLayout.addWidget(self.filterDomainCombo, 1, 0, 1, 4)
filterPatternLabel = QtWidgets.QLabel("&Filter pattern:")
filterPatternLabel.setBuddy(self.filterPatternLineEdit)
groupGridLayout.addWidget(filterPatternLabel, 2, 0, 1, 4)
groupGridLayout.addWidget(self.filterPatternLineEdit, 3, 0, 1, 4)
groupGridLayout.addWidget(self.filterCaseSensitivityCheckBox, 4, 0, 1, 4)
groupGridLayout.addWidget(self.filterSyntaxCheckBox, 5, 0, 1, 4)
gbox.addWidget(groupFilter, 4, 0, 1, 2)
self.btnRemove = QPushButton("Remove from comparator")
self.btnExpandSelected = QPushButton("Expand")
self.btnCollapseSelected = QPushButton("Collapse")
self.btnMoveUp = QPushButton("Move up")
self.btnMoveDown = QPushButton("Move Down")
self.btnSave = QPushButton("Save")
self.btnCancel = QPushButton("Cancel")
gbox.addWidget(self.btnRemove, 5, 0, 1, 2)
gbox.addWidget(self.btnExpandSelected, 6, 0, 1, 1)
gbox.addWidget(self.btnCollapseSelected, 6, 1, 1, 1)
gbox.addWidget(self.btnMoveUp, 8, 0, 1, 1)
gbox.addWidget(self.btnMoveDown, 8, 1, 1, 1)
gbox.addWidget(self.btnSave, 9, 0, 1, 1)
gbox.addWidget(self.btnCancel, 9, 1, 1, 1)
# deal with the main tree view
# TODO: think about reset data/load data
self.qCompViewer = ArticleViewer()
self.comp = Comparator()
self.originalComp = None
srcModel = SourceArticleDBModel(self.comp)
self.qCompViewer.setSourceModel(srcModel)
self.qCompViewer.setDefaultHeaderView()
self.qCompViewer.proxyModel.setDynamicSortFilter(False)
# finally the splitter
splitter1 = QSplitter(QtCore.Qt.Horizontal)
splitter1.addWidget(leftFrame)
splitter1.addWidget(self.qCompViewer)
splitter1.setSizes([100, 200])
hbox.addWidget(splitter1)
self.setLayout(hbox)
self.filterPatternLineEdit.textChanged.connect(self.textFilterChanged)
self.filterSyntaxCheckBox.toggled.connect(self.textFilterChanged)
self.filterCaseSensitivityCheckBox.toggled.connect(self.textFilterChanged)
self.filterDomainCombo.currentIndexChanged.connect(self.textFilterDomainChanged)
self.btnExpandSelected.clicked.connect(self.qCompViewer.onClickExpandRows)
self.btnCollapseSelected.clicked.connect(self.qCompViewer.onClickCollapseRows)
self.btnRemove.clicked.connect(self.onClicked_RemoveFromComparator)
def _cmp_func_wrapper(self, cmp_opts=''):
'''Return function member of class Tester.Comparator.'''
return Comparator(**ast.literal_eval(cmp_opts)).cmp
best_data.loc[best_data['NumberOfTime30-59DaysPastDueNotWorse'] > 90,
'NumberOfTime30-59DaysPastDueNotWorse'] = 18
best_data.loc[best_data['NumberOfTime60-89DaysPastDueNotWorse'] > 90,
'NumberOfTime60-89DaysPastDueNotWorse'] = 18
best_data.loc[best_data['NumberOfTimes90DaysLate'] > 90,
'NumberOfTimes90DaysLate'] = 18
best_data = best_data.drop(
best_data[best_data['RevolvingUtilizationOfUnsecuredLines'] > 10].index)
df = df.drop('Unnamed: 0', axis=1)
df.to_csv(r"./data/processed_data.csv")
# 验证
tester = Comparator('SeriousDlqin2yrs')
tester.addDataset('missing data processed', df)
tester.addDataset('debt ratio outliers removed',
removed_debt_outliers) # 164 removed
tester.addDataset('debt ratio outliers replaced',
repalace_debt_ratio) # 164 removed
tester.addDataset('overdue outliers replaced', repalace98) #269 removed
tester.addDataset('utilization outliers removed', dfus) # 241 removed
tester.addDataset('overdue outliers removed', drop98)
tester.addDataset('outliers added', add_outliers)
tester.addDataset('best_data', best_data)
# rf_default = RandomForestClassifier()
# dbdt_default = GradientBoostingClassifier()
# tester.addModel('default RF', rf_default)
def __init__(self,
batch_size,
w_i,
w_f,
w_a,
comparator_network='VGG16',
gan_name='gan',
lr=.002,
decay=0.5):
self.img_shape = (256, 256, 3)
input_image = Input(shape=(256, 256, 3))
self.comp_network = Comparator(network=comparator_network)
self.feat_comp_size = self.comp_network.model.layers[19].output_shape
self.gen_inp_size = self.comp_network.model.layers[20].output_shape
self.noise_std = K.variable([0], dtype='float32')
self.batch_size = batch_size
#K.set_learning_phase(1)
self.generator = self.build_generator()
#self.feature_model=K.function([self.comp_network.model.layers[0].input],[self.comp_network.model.layers[53].output,self.comp_network.model.layers[54].output])
x = Lambda(lambda inputs: tf.image.resize_bilinear(
inputs, tf.stack([224, 224]), align_corners=True))(input_image)
l1 = Model(self.comp_network.model.input,
self.comp_network.model.layers[19].output)
l2 = Model(self.comp_network.model.input,
self.comp_network.model.layers[20].output)
y1 = l1(x)
y2 = l2(x)
self.feature_model = Model(input_image, [y1, y2], name="Comparator")
#feature_model=Model(self.comp_network.model.input,[self.comp_network.model.layers[19].output,self.comp_network.model.layers[20].output],name="Comparator")
#feature_model.trainable=False
feats = self.feature_model(input_image)
image_comp_features = feats[0]
image_gen_input = feats[1]
synth_image = self.generator(image_gen_input)
synth_feats = self.feature_model(synth_image)
synth_comp_features = synth_feats[0]
synth_gen_input = synth_feats[1]
self.discriminator = self.build_discriminator(self.noise_std)
dis_optimizer = Adam(lr=lr * .1, decay=decay)
self.discriminator.compile(loss='binary_crossentropy',
optimizer=dis_optimizer,
metrics=['accuracy'])
validity = self.discriminator([synth_image, synth_comp_features])
gen_optimizer = Adam(lr=lr, decay=decay)
self.combined = Model(input_image,
[validity, synth_image, synth_comp_features])
self.combined.compile(optimizer=gen_optimizer,
loss=[
'binary_crossentropy', 'mean_squared_error',
'mean_squared_error'
],
loss_weights=[w_a, w_i, w_f])
def test_very_small_delta(self):
self.assertEqual(-6.000000000000001, Comparator(-6, delta=1e-15))
self.assertNotEqual(-6.000000000000002, Comparator(-6, delta=1e-15))
def test_equality_with_delta(self):
self.assertEqual(5.5, Comparator(6, delta=0.5))
self.assertEqual(6.5, Comparator(6, delta=0.5))
self.assertNotEqual(6.51, Comparator(6, delta=0.5))
self.assertNotEqual(5.49, Comparator(6, delta=0.5))
def test_negative_numbers(self):
self.assertNotEqual(-5.5, Comparator(-6, delta=0.25))
self.assertEqual(-5.75, Comparator(-6, delta=0.25))
self.assertEqual(-6.25, Comparator(-6, delta=0.25))
self.assertNotEqual(-6.3, Comparator(-6, delta=0.25))
def __init__(self, tickerName):
self.tickerName = tickerName
self.comparator = Comparator(self.tickerName)
self.analyser = Analyser(self.tickerName, self.comparator)
