def test_update_as_dict(self): data = Data() data.__dict__.update({ "range": "1", "number_of_primes": 1, "duration": 1.0 }) self.assertEqual("1;1;1.0", data.__str__())
def setUp(self): self.alg = System(self.sc, config=StubConfig) self.data = Data(self.sc, config=StubConfig) self.maximum_weight = StubConfig.get('System', 'maximum_weight') # Replace all other recommenders with a # stub that likes every restaurant # This stub must be defined in default.cfg self.alg.recommenders = {'CuisineType': StubCuisineType(self.sc)} self.alg.weights = {'CuisineType': 1}
def revert_password(): user_url = Data.BASE_API_PATH + '/user/password/change' json = Data.json_for_update_password(Data.read_credentials()[1], Data.read_credentials()[2]) response = requests.post( user_url, headers=Authorization().authentification_with_new_password(), json=json) status_code = response.status_code return status_code
def run(self, c=5, param=100, n_fold_cv=10, kernel='RBF'): ''' Run tests with given parameters on currently loaded data @param c: SVM classifier parameter @param param: kernel parameter @param n_fold_cv: n-fold cross-validation parameter @param kernel: used kernel - possibilities in src/kernels.py @return: classification results ''' data = Data(dbfile=None, n_fold_cv=n_fold_cv) k = str2kernel[kernel](param=param) C = c self.svm = SVM(kernel=k, C=C) correct_sum = 0 test_len = 0 res = {} res['true_positive'] = 0.0 res['true_negative'] = 0.0 res['false_positive'] = 0.0 res['false_negative'] = 0.0 for i in xrange(n_fold_cv): X1, Y1, X2, Y2 = data.get(i) self._logger.info('Training SVM... (i={0})'.format(str(i))) self.svm.train(X1, Y1) if self.svm.model_exists: # predict Y_predict = self.svm.predict(X2) self._logger.info('using {0} of {1} support vectors'.format( self.svm.lm_count, self.svm.all_lm_count)) # calculate tp, fp, tn, fn test_len = len(Y_predict) Y_predict_P = Y_predict[:(test_len/2)] Y_predict_N = Y_predict[(test_len/2):] Y2_P = Y2[:(test_len/2)] Y2_N = Y2[(test_len/2):] tp = np.sum(Y_predict_P == Y2_P) fn = np.sum(Y_predict_P != Y2_P) tn = np.sum(Y_predict_N == Y2_N) fp = np.sum(Y_predict_N != Y2_N) res['true_positive'] += tp / float(n_fold_cv) res['false_positive'] += fp / float(n_fold_cv) res['true_negative'] += tn / float(n_fold_cv) res['false_negative'] += fn / float(n_fold_cv) # this iteration result self._logger.info('tp: {0}, fp: {1}, tn: {2}, fn :{3}'.format( str(tp), str(fp), str(tn), str(fn))) # print and return results self._calculate_results(res) return res
def regenerate_data(self, dbfile, count=1000, max_token_size=1): ''' Regenerate database files according to input parameters @param dbfile: database file containing anotated data @param count: used number of entries @param max_token_size: sets maximal size of word tokens @return: data transformed into SVM usable format ''' data = Data(dbfile=dbfile, max_token_size=max_token_size) data.regenerate_X1_X2(count) return data
def process_tests_text(bot: TeleBot, user: User, data: Data, text: str, user_func: Callable): test_action = text.split("__")[1] if test_action == "help": bot.send_message(user.chat_id, help_msg) elif test_action.startswith("edit"): btn_number = int(text.split("-")[-1]) elif test_action == "update": data.update_ejf_table() bot.send_message(user.chat_id, text="EJF table has been updated") elif test_action == "resetquiz": user.additional_info = None user.save() bot.send_message( user.chat_id, text="You can now click /start and take a quiz again.") elif test_action == "user": user_func(user) elif test_action == "test_blocked": blocked_counter = 0 unblocked_counter = 0 for u in User.objects: try: m = bot.send_message(chat_id=u.chat_id, text="check") bot.delete_message(chat_id=u.chat_id, message_id=m.message_id) if u.is_blocked: u.is_blocked = False bot.send_message( user.chat_id, text=f"{u.chat_id} @{u.username} unblocked!!!!") u.save() unblocked_counter += 1 except Exception as e: bot.send_message(user.chat_id, text=f"{u.chat_id} @{u.username} {e}") if u.is_blocked is False: u.is_blocked = True u.save() blocked_counter += 1 bot.send_message( user.chat_id, text= f"Заблоковано нових {blocked_counter}\nРозблоковано нових {unblocked_counter}", )
def parse_dat_file(self): self.dat_dict = {} count = 0 for fname in self.all_file_list: count += 1 print("{}/{} Reading... {}".format(count, len(self.all_file_list), fname)) data = Data() dat = parse_dat(fname) self.dat_dict[fname] = dat data.dat_data = dat self.data_dict[fname] = data
def trainmodel(): fvocab = "data/sample/vocab.pickle.gz" fdata = "data/sample/trn.data" flabel = "data/sample/trn.label" D = load(gzip.open(fvocab)) vocab, labelidxmap = D['vocab'], D['labelidxmap'] print('len(vocab) = {}'.format(len(vocab))) data = Data() trnM, trnL = data.loadmatrix(fdata, flabel) print('trnM.shape = {}'.format(trnM.shape)) idxlabelmap = reversedict(labelidxmap) pm = ParsingModel(vocab=vocab, idxlabelmap=idxlabelmap) pm.train(trnM, trnL) pm.savemodel("models/parsing-model.pickle.gz")
def change_password(self): content = [] user_url = Data.BASE_API_PATH + '/user/password/change' json = Data.json_for_update_password(Data.read_credentials()[2], Data.read_credentials()[1]) response = requests.post(user_url, headers=self.user_access_token, json=json) status_code = response.status_code content.append(status_code) response = response.json() content.append(response) content.append(Data.json_for_create_user()) return content
def update_project(self, project): project_url = Data.BASE_API_PATH + 'project/' + project response = requests.put(project_url, headers=self.admin_token, json=Data.json_for_update_project()) content = ApiHelper.content(response) return content
class RangeOfNumbers: data = Data() _increment = 1 * 1000 * 1000 @staticmethod def get_increment(): return RangeOfNumbers._increment def __init__(self, start: int = 0, final: int = None): self.start = start self.final = final if final else start + self.get_increment() self.file = f'{self.start}-{self.final}' def calculate(self): a = time.time() self.create_files() b = time.time() self.data.__dict__.update({'duration': round(b - a, 5)}) export_information(self.data) def create_files(self): if not os.path.exists(path_files): os.mkdir(path_files) range_start, range_end = self.file.split('-') list = prime_list(int(range_start), int(range_end)) write_primes(f"primos-{range_start}-{range_end}.txt", list) self.data.__dict__.update({ 'range': self.file, 'number_of_primes': len(list) }) def __str__(self): return f'start: {self.start}, end: {self.final}, file: {self.file}'
class TestData: data = { 'device': '1', 'seqNumber': 0, 'data': { 'temperature': 10, 'latitude': 38, 'longitude': 20 }, 'time': '2019-10-10 17:00:00' } dataR = Data() def test_received(self): rec = self.dataR.received(json.dumps(self.data)) assert self.data.get('device') == rec.get('device') assert self.data.get('seqNumber') == rec.get('seqNumber') assert self.data.get('data').get('temperature') == rec.get('data').get( 'temperature') def test_get_data(self): rec = self.dataR.received(json.dumps(self.data)) getted = self.dataR.get_data() assert getted.get('device') == rec.get('device') assert getted.get('seqNumber') == rec.get('seqNumber') assert getted.get('data').get('temperature') == rec.get('data').get( 'temperature')
def read_information(): import datetime """ Read information from csv file :return: Information """ dat: [Data] = [] with open(f'{csv_file}', "r") as file: lines = file.readlines() for l in lines[1:]: dat.append( Data( l.split(';')[0], int(l.split(';')[1]), float(l.split(';')[2]))) primos = 0 tiempo = 0 for d in dat: primos += d.number_of_primes tiempo += d.duration info = { 'rangos': len(dat), 'primos': primos, 'tiempo': str(datetime.timedelta(seconds=tiempo)) } print(info)
def openDialog(self): # Only single instance of Plugin if self.exists == True: return else: self.exists = True self.resources = Resources(self.plugin_dir) self.dlg = PlanHeatDMMDialog(self) self.data = Data(plugin=False) splash = QSplashScreen( QtGui.QPixmap(self.plugin_dir + os.path.sep + 'resources/PlanHeatPrincipal.png'), QtCore.Qt.WindowStaysOnTopHint) splash.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.FramelessWindowHint) splash.setEnabled(False) splash.show() # Run the dialog event loop self.run() splash.finish(self.dlg) self.dlg.show() result = self.dlg.exec_() self.exists = False # See if OK was pressed if result: # Do something useful here pass else: pass
def resolve_route(project_route, page_route, doc_route): project = Data.get_project(project_route) if project is None: return Routing.show_projects_page() if project.has_pages() is False: logging.error('Project ' + project.display_name + ' has no pages') return Routing.show_projects_page() # Try to get page by route if it is defined # otherwise get the first page. page = project.get_page(page_route) if page == None: return Routing.show_projects_page() # If the page has no documents, try to fetch first page with documents # If not, redirect to project page. if page.has_documents() is False: page = project.get_page_with_docs() if page == None: return Routing.show_projects_page() doc = page.get_document(doc_route) if doc == None: return Routing.show_projects_page() return render_template('index.html', base_href=Routing.base_href, selected_page=page, page=page, doc_route=doc.route, docs=page.documents, html_content=doc.to_html(), project=project)
def upload_photo(self, photo): data_url = Data.BASE_API_PATH + '/data/photo' response = requests.post(data_url, headers=self.user_access_token, files=Data.return_photo(photo)) content = ApiHelper.content(response) return content
def run(self): """Run method that performs all the real work""" try: # locale.setlocale(locale.LC_ALL, 'en-GB') # Only single instance of Plugin if self.exists == True: return else: self.exists = True self.dlg = PlanHeatDMMDialog(self) self.resources = Resources(self.plugin_dir) self.data = Data(plugin=True) # Name of project self.data.projectName = master_mapping_config.CURRENT_PROJECT_NAME # Redirection dmm_folder = os.path.join(master_mapping_config.CURRENT_MAPPING_DIRECTORY, master_mapping_config.DMM_FOLDER) os.makedirs(dmm_folder, exist_ok=True) self.data.outputSaveFile = os.path.join(dmm_folder, master_mapping_config.DMM_PREFIX) splash = QSplashScreen(QtGui.QPixmap(self.plugin_dir + os.path.sep + 'resources/PlanHeatPrincipal.png'), QtCore.Qt.WindowStaysOnTopHint) splash.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.FramelessWindowHint) splash.setEnabled(False) splash.show() # Run the dialog event loop initWindowStatus(self) self.resources.loadAppResources() initWindowbehavior(self) # Deserialize the module DMMSerializer.deserialize(self) splash.finish(self.dlg) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() self.exists = False # See if OK was pressed if result: # Do something useful here - pass else: pass except Exception as e: self.exists = False print(str(e))
def assign_user_on_project(self, project): project_url = Data.BASE_API_PATH + 'project/' + project + '/assign' response = requests.put( project_url, headers=self.admin_token, json=Data.json_for_assign_user('user_for_assignee')) content = ApiHelper.content(response) return content
def create_new_dashboard(self): project = ApiHelper.get_project_name(self) project_url = Data.BASE_API_PATH + project + '/dashboard' response = requests.post(project_url, headers=self.user_access_token, json=Data.json_for_create_dashboard()) content = ApiHelper.content(response) return content
def update_dashboard(self, dashboard_id): project = ApiHelper.get_project_name(self) project_url = Data.BASE_API_PATH + project + '/dashboard/' + dashboard_id response = requests.put(project_url, headers=self.user_access_token, json=Data.json_for_update_dashboard()) content = ApiHelper.content(response) return content
def create_user(self, *args): content = [] user_url = Data.BASE_API_PATH + '/user' if args: json = Data.json_for_create_user(args) response = requests.post(user_url, headers=self.admin_token, json=json) else: json = Data.json_for_create_user() response = requests.post(user_url, headers=self.admin_token, json=json) status_code = response.status_code content.append(status_code) response = response.json() content.append(response) content.append(json) return content
class DataTest(TestCase, BaseTestCase): @classmethod def setUpClass(self): self.data = Data(self.sc, StubConfig) def test_main(self): # Test nearby restaurant detection nearby = self.data.nearby_restaurants(self.bookings) self.assertIsInstance(nearby, RDD) self.assertTrue(nearby.count() > 0) self.assertTrue(len(nearby.first()) == 2) # Test outlier filtering filtered = self.data.filter_outliers(self.bookings) self.assertIsInstance(filtered, DataFrame) self.assertTrue(filtered.count() < self.bookings.count()) @classmethod def tearDownClass(self): del self.data
def __init__(self) -> None: super().__init__() # 加载UI self.ui = ui_main.Ui_MainWindow() self.ui.setupUi(self) # 加载数据 self.data = Data(self) self.data.setItems() # 绑定槽函数 ## 数据.添加项 self.add_window = InfoEditor() self.ui.item_add.triggered.connect(self.add_window.show) # 显示窗口 self.add_window.ui.ok.clicked.connect(self.data.addItem) # (窗口) 确认 self.add_window.ui.close.clicked.connect( self.add_window.close) # (窗口) 关闭 ## 数据.删除项 self.ui.item_remove.triggered.connect(self.data.rmItem) ## 编辑.信息 self.change_window = InfoEditor() self.ui.item_change.triggered.connect(self.chitem_show) # 显示窗口 self.change_window.ui.ok.clicked.connect(self.data.chItem) # (窗口) 确认 self.change_window.ui.close.clicked.connect( self.change_window.close) # (窗口) 关闭 ## 编辑.内容 self.markdown_editor = MarkdownEditor() self.ui.content.triggered.connect(self.markdown_editor_show) # 显示窗口 self.markdown_editor.ui.open.triggered.connect( self.markdown_editor_open) self.markdown_editor.ui.save.triggered.connect( self.markdown_editor_save) self.markdown_editor.ui.view.triggered.connect( self.markdown_editor_view) ## 查找.排序 self.ui.sort.triggered.connect(self.item_sort) ## 查找.搜索 self.search_window = FindEditor() self.ui.search.triggered.connect(self.search_window.show) self.search_window.ui.submit.clicked.connect(self.item_find)
class SystemAlgorithmTest(TestCase, BaseTestCase): def setUp(self): self.alg = System(self.sc, config=StubConfig) self.data = Data(self.sc, config=StubConfig) self.maximum_weight = StubConfig.get('System', 'maximum_weight') # Replace all other recommenders with a # stub that likes every restaurant # This stub must be defined in default.cfg self.alg.recommenders = {'CuisineType': StubCuisineType(self.sc)} self.alg.weights = {'CuisineType': 1} def test01_predict(self): self.alg.train(self.bookings) # Check that predictions match interface self.assertIsInstance( self.alg.predict(self.data.nearby_restaurants(self.bookings)), DataFrame) # Check for detection of empty RDD self.assertRaises(ValueError, self.alg.predict, self.sc.parallelize([])) def test02_weights(self): self.alg.recommenders = {"a": "a", "b": "b", "c": "c"} weights = self.alg.generate_weights(self.maximum_weight) for tpl in weights: # All coefficients are in [0, maximum_weight] for val in tpl: self.assertTrue(0 <= val <= self.maximum_weight) # Ensure tuples that are integer multiples # of other tuples are not present for tpl2 in weights: if tpl != tpl2: self.assertFalse(collinear(tpl, tpl2)) def test03_learn(self): self.alg.config.set_weights((1, 1, 1, 1)) self.alg.learn_hyperparameters(self.bookings) # After learning, at least one recommender should have a # non-zero weight, i.e., the sum has to be positive self.assertTrue(sum(self.alg.config.get_weights()) > 0) def tearDown(self): del self.alg del self.data
def __init__(self): data = Data() def empty_check(dict): if dict: return False else: return True with open('final_data.txt', 'r+') as f: # set text inside to this var which is now a list of our data a_data = ast.literal_eval(f.read()) a_data = [d for d in a_data if d] self.df = pd.DataFrame(a_data) self.df.dropna() self.df.isna()
def create_project(self, *args): content = [] request_json = Data.json_for_create_new_project() project_url = Data.BASE_API_PATH + 'project' if args: response = requests.post(project_url, headers=self.admin_token, json=request_json) else: response = requests.post(project_url, headers=self.user_access_token, json=request_json) status_code = response.status_code content.append(status_code) response = response.json() content.append(response) content.append(request_json["projectName"]) return content
def detect_type(self): for data in self.data_list: d = Data(data) if (d.my_type == 'ENC'): continue elif ('KEY' in d.my_type): d = Key(data) # creation de la class Key elif ('CRT' in d.my_type): try: # creation de la class Certificat avec PEM d = Certificate(data, 'PEM') except: continue elif ('DER' in d.my_type): try: # creation de la class Certificat avec DER d = Certificate(data, 'DER') except: continue self.objects_list.append(d) return len(self.objects_list)
import xgboost as xgb import numpy as np from sklearn.ensemble import RandomForestRegressor import src.constants as const from src.data import Data from src.evaluation import Evaluator as eval from src.params import Params from src.visualization import Visualisation as visual input_files = [ f for f in listdir(const.data_path) if isfile(join(const.data_path, f)) ] data = Data(input_files, fill_strategy='gate') params = Params() visual.create_feature_map(data.lagged_feature_names) #visual.plot2d(data, 'crude_oil') #visual.plot_all_2d(data) # Global variables xgb_num_rounds = 80 td = np.array(data.train_data.drop(['output'], axis=1)) train_data = data.train_data.drop(['output'], axis=1).as_matrix() train_label = data.train_data[['output']].as_matrix() test_data = data.test_data.drop(['output'], axis=1).as_matrix()
def main(): tesla_filename = os.path.join(DATA_DIR, 'TSLA.csv') hitachy_filename = os.path.join(DATA_DIR, './HTHIY.csv') # Hitachi, Ltd. ivr_filename = os.path.join(DATA_DIR, './IYR.csv') # iShares U.S. Real Estate ETF lithium_filename = os.path.join( DATA_DIR, './LIT.csv') # Global X Lithium & Battery Tech ETF (LIT) # Read CSV files into Panda Dataframes r_y = Data(tesla_filename) y = r_y.to_panda('tesla') r_x1 = Data(hitachy_filename) x1 = r_x1.to_panda('hitachy') r_x2 = Data(lithium_filename) x2 = r_x2.to_panda('lithium') r_x3 = Data(ivr_filename) x3 = r_x3.to_panda('ivr') from functools import reduce data_frames = [ x1.drop(['hitachy_price'], axis=1), x2.drop(['lithium_price'], axis=1), x3.drop(['ivr_price'], axis=1), y.drop(['tesla_price'], axis=1) ] df_merged = reduce( lambda left, right: pd.merge(left, right, on=['Date'], how='outer'), data_frames).fillna('void') # Get the correlation Matrix dt = DataTool(df_merged) dt.corr_matrix(OUT_DIR) # Stack multiple independent variables, only keep the Returns columns x = np.vstack( (x1['hitachy_returns'], x2['lithium_returns'], x3['ivr_returns'])) x = x.T y = y['tesla_returns'] # Apply linear regression regression = Regression() model = regression.createModel() model.fit(x, y) model.score(x, y) # R-square import statsmodels.api as sm # By default statsmodel does not include intercept for regression (A in : y = A + B*x1 + C*x2 ) X = sm.add_constant(x) # Create Ordinary Least-Squares (OLS) model sm_model = sm.OLS(y, X) fit = sm_model.fit() # Save summary in pickle fit.save(OUT_DIR + "/fit_summary.pickle") with open(OUT_DIR + "/fit_summary.txt", 'w') as f: print(fit.summary(), file=f) print(fit.summary())
# -*- coding:UTF-8 -*- """ @author: ZhaoHe """ from src.data import Data from src.config import dataset2_table_name if __name__ == "__main__": data = Data() # 处理数据集的标称属性 data.process_nom_features(data.dataset2_nom_feature_list, dataset2_table_name)
from src import app, api from flask_restful import Resource from src.data import Data from src.models import Pair, Interval data = Data() class HelloWorld(Resource): def get(self): return {'hello': 'world'} class Test(Resource): def get(self): return {'results':data.test()} class History(Resource): def get(self, symbol_1:str, symbol_2:str, _datetime:int): pair = Pair(symbol_1, symbol_2) res = data.history(pair, _datetime) return res class HistoryRange(Resource): def get(self, symbol_1:str, symbol_2:str, datetime_start:int, datetime_end:int, interval:str): pair = Pair(symbol_1, symbol_2) interval = Interval(interval) res = data.history(pair, datetime_start, datetime_end, interval) return res api.add_resource(HelloWorld, '/') api.add_resource(Test,'/test') api.add_resource(History,'/history/<string:symbol_1>/<string:symbol_2>/<int:_datetime>') api.add_resource(HistoryRange,'/history/<string:symbol_1>/<string:symbol_2>/<int:datetime_start>/<int:datetime_end>/<string:interval>')
class Solver: def __init__(self, data): self.data = data self.initial_guess = [1, 1, 1, data.center[0], data.center[1]] # constraint function (x[0] == a, x[1] == b, x[2] == c, x[3] == d, x[4] == alpha, x[5] == beta) # def h(self, x, number): # det = x[0] * x[3] - x[1] * x[2] # if det == 0: # return - 1 # 1 is more than 0 so the constraint does not hold # else: # return -((1 / det ** 2) * ((x[3] * self.data.df.iloc[0, number] - x[1] * (self.data.df.iloc[1, number] # - x[4] * (det ** 2))) ** 2 # + (x[0] * self.data.df.iloc[1, number] - x[2] * self.data.df.iloc[0, number] # - x[5] * (det ** 2)) ** 2) - 1) def h(self, x, number): return 1 - ( (x[0]**2 * self.data.new_df.iloc[0, number] + x[0] * x[2] * self.data.new_df.iloc[1, number] - x[3])**2 + (x[0] * x[2] * self.data.new_df.iloc[0, number] + (x[1]**2 + x[2]**2) * self.data.new_df.iloc[1, number] - x[4])**2) # variables used for finding out whether to discard the point point_cost = 10 square_cost = 1 # cost of one m^2 of area square = 0.0 # ellipse area - target function value x = 0.0 # elements of S y = 0.0 z = 0.0 alpha = 0.0 # shift vector beta = 0.0 vector = np.zeros(5) data = Data() # Data object will be transferred here initial_guess = np.zeros(5) def set_fields(self, x, y, z, alpha, beta): # self.a = a # self.b = b # self.c = c # self.d = d # self.alpha = alpha # self.beta = beta # self.vector = [a, b, c, d, alpha, beta] self.x = x self.y = y self.z = z self.alpha = alpha self.beta = beta self.vector = [x, y, z, alpha, beta] def restrictions( self): # counting all restrictions and assembling together cons = list() # list of dictionaries h_list = list() # list of constraints - functions h_i # number of restrictions == number of points left (columns in new_df) for i in range(len(self.data.new_df.columns)): h_list.append(lambda x: self.h(x, i)) cons.append({ 'type': 'ineq', 'fun': h_list[i] }) # appending each constraint as a dictionary return cons def optimize(self): # computing matrix S and vector (alpha, beta)^T w = self.minimal_result() self.set_fields(w[0], w[1], w[2], w[3], w[4]) current_square = f(w[0:3]) # latest calculated square # print("\n" + "Starting square is " + str(current_square)) self.data.discard_point(False) while True: self.square = current_square w = self.minimal_result() current_square = f(w[0:3]) delta_square = self.square - current_square # area change if delta_square * self.square_cost < self.point_cost: break self.set_fields(w[0], w[1], w[2], w[3], w[4]) self.data.discard_point(False) # counting optimal values for points in new_df def minimal_result(self): result = minimize(f, self.initial_guess, constraints=self.restrictions()) return result.x def display(self): # Let ellipse be (x y)*Q*(x y)^T + L^T*(x y) + c # set edges for of displayed field edge = 40.0 x_min = -edge x_max = edge y_min = -edge y_max = edge axes = plt.gca() axes.set_xlim([x_min, x_max]) axes.set_ylim([y_min, y_max]) x = np.linspace(-20.0, 20.0, 100) y = np.linspace(-20.0, 20.0, 100) xx, yy = np.meshgrid(x, y) # draw the ellipse # ellipse = ((self.a ** 2 + self.c ** 2) * xx) ** 2 + 2 * (self.a * self.b + self.c * self.d) * xx * yy \ # + ((self.b ** 2 + self.d ** 2) * yy) ** 2 - 2 * (self.alpha * self.a + self.beta * self.c) * xx \ # - 2 * (self.alpha * self.b + self.beta * self.d) * yy + self.alpha ** 2 + self.beta ** 2 - 1 ellipse = 0 plt.contour(xx, yy, ellipse, [0]) # just draw points for i in range(len(self.data.df.columns)): plt.plot(self.data.df.iloc[0, i], self.data.df.iloc[1, i], 'bo') plt.show()