def calculate_confusion_matrices_per_classification(self): """Parameters ---------- Returns ------- A dict with keys of workflow IDs and values list of golden sets associated with that workflow """ # Load classifications, and golden images from DB # Make sure choice is a valid index # Make sure to evaluate only logged in users # Ignore NONEOFTHEABOVE classificatios when constructing confusion # matrix # Make sure to the subject classified was a golden image query = 'classificationsdev WHERE \"annotations_value_choiceINT\" != \ -1 AND \"links_user\" != 0 AND \ \"annotations_value_choiceINT\" != 12 AND \ CAST(links_subjects AS FLOAT) IN \ (SELECT \"links_subjects\" FROM goldenimages)' columns = [ 'id', 'links_user', 'links_subjects', 'links_workflow', 'annotations_value_choiceINT' ] classifications = EventTable.fetch('gravityspy', query, columns=columns) classifications = classifications.to_pandas() classifications = classifications.sort_values('id') golden_images = EventTable.fetch('gravityspy', 'goldenimages') golden_images_df = golden_images.to_pandas() # From answers Dict determine number of classes numClasses = len(self.get_answers(workflow=7766).values()[0]) # merge the golden image DF with th classification (this merge is on # links_subject (i.e. the zooID of the image classified) image_and_classification = classifications.merge(golden_images_df, on=['links_subjects']) # groupby users to get there gold classifications tmp = image_and_classification.groupby('links_user')[[ 'annotations_value_choiceINT', 'GoldLabel', 'id' ]] user_confusion_matrices = {} for key, item in tmp: user_confusion_matrices[key] = {} userlabels = tmp.get_group(key) rows = [] cols = [] entry = [] for ilabel in userlabels.sort_values('id').itertuples(): rows.append(ilabel[2]) cols.append(ilabel[1]) entry.append(1) user_confusion_matrices[key][ilabel[3]] = coo_matrix( (entry, (rows, cols)), shape=(numClasses, numClasses)) return user_confusion_matrices
def clean(self): cleaned_data = super(LIGOSearchForm, self).clean() zooid = cleaned_data.get('zooid') imageid = cleaned_data.get('imageid') gpstime = cleaned_data.get('gpstime') ifos = cleaned_data.get('ifo') database = cleaned_data.get('database') if (zooid and imageid and gpstime) or (zooid and imageid) or \ (zooid and gpstime) or (gpstime and imageid): raise forms.ValidationError("Please fill out " "only one of the zooid " "or gravityspy id fields" ) elif (not zooid) and (not imageid) and (not gpstime): raise forms.ValidationError("Please fill out " "one but not both of the zooid " "and gravityspy id fields" ) if zooid and not imageid and not gpstime: if EventTable.fetch('gravityspy', '{0} WHERE links_subjects = {1}'.format(database, zooid), columns=['links_subjects'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("zooid does not exist" ) if imageid and not zooid and not gpstime: if EventTable.fetch('gravityspy', '{0} WHERE \"gravityspy_id\" = \'{1}\''.format(database, imageid), columns=['gravityspy_id'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("uniqueid does not exist" )
def clean(self): cleaned_data = super(LIGOSearchForm, self).clean() zooid = cleaned_data.get('zooid') imageid = cleaned_data.get('imageid') gpstime = cleaned_data.get('gpstime') if (zooid and imageid and gpstime) or (zooid and imageid) or \ (zooid and gpstime) or (gpstime and imageid): raise forms.ValidationError("Please fill out " "only one of the zooid " "or gravityspy id fields" ) elif (not zooid) and (not imageid) and (not gpstime): raise forms.ValidationError("Please fill out " "one but not both of the zooid " "and gravityspy id fields" ) if zooid and not imageid and not gpstime: if EventTable.fetch('gravityspy', 'similarityindex WHERE links_subjects = {0}'.format(zooid), columns=['links_subjects']).to_pandas().empty: raise forms.ValidationError("zooid does not exist" ) if imageid and not zooid and not gpstime: if EventTable.fetch('gravityspy', 'similarityindex WHERE \"uniqueID\" = \'{0}\''.format(imageid), columns=['uniqueID']).to_pandas().empty: raise forms.ValidationError("uniqueid does not exist" )
def check_level_by_classification(self): # Obtain workflow order order = self.project_info['configuration_workflow_order'] workflows = [int(str(iWorkflow)) for iWorkflow in order] levelWorkflowDict = dict(enumerate(workflows)) workflowLevelDict = dict( (v, k + 1) for k, v in levelWorkflowDict.iteritems()) query = 'classificationsdev GROUP BY links_user, links_workflow' userlevels = EventTable.fetch('gravityspy', query, columns=['links_user', 'links_workflow']) userlevels = userlevels.to_pandas() userlevels['Level'] = userlevels.links_workflow.apply( lambda x: workflowLevelDict[x]) init_user_levels = userlevels.groupby('links_user').Level.max() init_user_levels_dict = { 'userID': init_user_levels.index.tolist(), 'workflowInit': init_user_levels.tolist() } userStatusInit = pd.DataFrame(init_user_levels_dict) self.userStatusInit = userStatusInit return userStatusInit
def dategraph(request): # if this is a POST request we need to process the form data if request.method == 'GET': # create a form instance and populate it with data from the request: form = SearchForm(request.GET) # check whether it's valid: if form.is_valid(): username = str(form.cleaned_data['username']) collection_display_name = str( form.cleaned_data['collection_display_name']) subjects_in_collection, tmp = retrieve_subjects_from_collection( username, collection_display_name) subjects_in_collection = [ str(isubject) for isubject in subjects_in_collection ] SI_glitches = EventTable.fetch( 'gravityspy', 'glitches WHERE CAST(links_subjects AS FLOAT) IN ({0})'.format( str(",".join(subjects_in_collection))), host='gravityspyplus.ciera.northwestern.edu').to_pandas() fig = obtain_figure(SI_glitches) canvas = FigureCanvas(fig) buf = io.BytesIO() canvas.print_png(buf) response = HttpResponse(buf.getvalue(), content_type='image/png') fig.clear() return response
def collectioninfo(request): # if this is a POST request we need to process the form data if request.method == 'GET': # create a form instance and populate it with data from the request: form = SearchForm(request.GET) # check whether it's valid: if form.is_valid(): username = str(form.cleaned_data['username']) collection_display_name = str( form.cleaned_data['collection_display_name']) subjects_in_collection, tmp = retrieve_subjects_from_collection( username, collection_display_name) subjects_in_collection = [ str(isubject) for isubject in subjects_in_collection ] SI_glitches = EventTable.fetch( 'gravityspy', 'glitches WHERE CAST(links_subjects AS FLOAT) IN ({0})'.format( str(",".join(subjects_in_collection))), host='gravityspyplus.ciera.northwestern.edu').to_pandas() dategraph_url = request.get_full_path()[::-1].replace( 'collection-info'[::-1], 'dategraph'[::-1], 1)[::-1] return render( request, 'collection_results.html', { 'results': SI_glitches.to_dict(orient='records'), 'dategraph_url': dategraph_url }) else: return render(request, 'collectioninfo.html', {'form': form})
def retrain_model(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = NewClassForm(request.POST) # check whether it's valid: if form.is_valid(): collection_owner = str(form.cleaned_data['collection_owner']) collection_name = str(form.cleaned_data['collection_name']) new_class_name = str(form.cleaned_data['new_class_name']) # First determine the subjects attempting to be added to the training set subjects_in_collection, tmp = retrieve_subjects_from_collection(collection_owner, collection_name) subjects_in_collection = [str(isubject) for isubject in subjects_in_collection] new_subjects = list(EventTable.fetch('gravityspy', 'glitches WHERE CAST(links_subjects AS FLOAT) IN ({0})'.format(str(",".join(subjects_in_collection))), columns=["gravityspy_id"], host='gravityspyplus.ciera.northwestern.edu')['gravityspy_id']) requested_model, created = NewClass.objects.get_or_create(collection_owner=collection_owner, collection_name=collection_name, new_class_name=new_class_name, new_subjects=new_subjects, user=request.user) requested_model.save() return render(request, 'temp.html') else: return render(request, 'retrain-model-form.html', {'form': form})
def collectioninfo(request): # if this is a POST request we need to process the form data if request.method == 'GET': # create a form instance and populate it with data from the request: form = SearchForm(request.GET) # check whether it's valid: if form.is_valid(): username = str(form.cleaned_data['username']) collection_display_name = str(form.cleaned_data['collection_display_name']) subjects_in_collection = retrieve_subjects_from_collection(username, collection_display_name) subjects_in_collection = [str(isubject) for isubject in subjects_in_collection] SI_glitches = EventTable.fetch('gravityspy', 'glitches WHERE CAST(links_subjects AS FLOAT) IN ({0})'.format(str(",".join(subjects_in_collection)))).to_pandas() GlitchValues = SI_glitches.values GlitchGPS = (GlitchValues[:,4]).tolist() newestGPS = (max(GlitchGPS)) oldestGPS = (min(GlitchGPS)) print (newestGPS) print (oldestGPS) #converting newest and oldest to dates newest = timeconvert.gps2ppl(newestGPS) oldest = timeconvert.gps2ppl(oldestGPS) print (newest) print (oldest) #number of weeks def nofweeks(d1,d2): d1 = datetime.datetime.strptime(d1, "%Y-%m-%d %H:%M") d2 = datetime.datetime.strptime(d2, "%Y-%m-%d %H:%M") hop = ((abs((d2 - d1).days))/7) if hop > 1: return hop elif hop <= 1: return 1 print (nofweeks(newest, oldest)) #checking and changing xlocs, xlabels plt.hist(GlitchGPS, bins = (nofweeks(newest, oldest))) xlocs, xlabels = plt.xticks() print (xlocs) GPSlabels = list() for x in range(len(xlocs)): GPSlabels.append(timeconvert.gps2ppl(xlocs[x])) plt.xticks(xlocs, GPSlabels, rotation = 45) plt.title("Distribution of Glitches \n Each Bin Represents One Week") plt.xlabel("Time") plt.ylabel("Number of Glitches per Week") plt.tight_layout() plt.hist(GlitchGPS, bins = (nofweeks(newest, oldest))) xlocs, xlabels = plt.xticks() print (xlocs) plt.savefig("final.png") return render(request, 'searchresults.html', {'results': SI_glitches.to_dict(orient='records')})
def searchDB(form): # process the data in form.cleaned_data as required # process the data in form.cleaned_data as required glitchclass = str(form.cleaned_data['glitchclass']) SI_glitches = EventTable.fetch('gravityspy', 'trainingset WHERE \"Label\" = \'{0}\''.format(glitchclass), columns = ['gravityspy_id', 'Filename1', 'Filename2', 'Filename3', 'Filename4', 'ifo', 'snr', 'peak_frequency', 'Label']).to_pandas() SI_glitches['url1'] = SI_glitches[['ifo', 'Filename1']].apply(makelink, axis=1) SI_glitches['url2'] = SI_glitches[['ifo', 'Filename2']].apply(makelink, axis=1) SI_glitches['url3'] = SI_glitches[['ifo', 'Filename3']].apply(makelink, axis=1) SI_glitches['url4'] = SI_glitches[['ifo', 'Filename4']].apply(makelink, axis=1) return SI_glitches
def training_set_raw_data(filename, format, duration=8, sample_frequency=4096, verbose=False, **kwargs): """Obtain the raw timeseries for the whole training set Parameters: filename (str): format (str): duration (int, optional): sample_frequency (int, optional): verbose (bool, optional): Returns: A file containing the raw timeseries data of the training set """ logger = log.Logger('Gravity Spy: Obtaining TimeSeries' ' Data For Trainingset') trainingset_table = EventTable.fetch( 'gravityspy', 'trainingsetv1d1', columns=['event_time', 'ifo', 'true_label']) for ifo, gps, label in zip(trainingset_table['ifo'], trainingset_table['event_time'], trainingset_table['true_label']): logger.info('Obtaining sample {0} with gps {1} from ' '{2}'.format(label, gps, ifo)) data = fetch_data(ifo, gps, duration=duration, sample_frequency=sample_frequency, verbose=verbose, **kwargs) logger.info('Writing Sample To File..') data.write(filename, format=format, append=True, path='/data/{0}/{1}/'.format(label, gps))
def histogram(request): # if this is a POST request we need to process the form data if request.method == 'GET': # create a form instance and populate it with data from the request: form = PosteriorForm(request.GET) # check whether it's valid: if form.is_valid(): graceid = form.cleaned_data['graceid'] param1 = form.cleaned_data['param1'] param2 = form.cleaned_data['param2'] param1_min = form.cleaned_data['param1_min'] param1_max = form.cleaned_data['param1_max'] param2_min = form.cleaned_data['param2_min'] param2_max = form.cleaned_data['param2_max'] client = GraceDb("https://gracedb-playground.ligo.org/api/") #event = client.event(graceid) #filename = client.files(graceid, 'event.log') ps = EventTable.fetch( 'gravityspy', '\"{0}\"'.format(graceid), selection=[ '{0}<{1}<{2}'.format(param1_min, param1, param1_max), '{0}<{1}<{2}'.format(param2_min, param2, param2_max) ], columns=[param1, param2]) ps = ps.to_pandas().iloc[0:1000] with seaborn.axes_style('white'): plot = seaborn.jointplot(param1, param2, ps, kind='kde') fig = plot.fig canvas = FigureCanvas(fig) import io buf = io.BytesIO() canvas.print_png(buf) response = HttpResponse(buf.getvalue(), content_type='image/png') fig.clear() return response
def clean(self): cleaned_data = super(SearchForm, self).clean() zooid = cleaned_data.get('zooid') imageid = cleaned_data.get('imageid') ifos = str(cleaned_data.get('ifo')) database = cleaned_data.get('database') era = cleaned_data.get('era') if zooid and imageid: raise forms.ValidationError("Please fill out " "only one of the zooid " "or gravityspy id fields" ) elif (not zooid) and (not imageid): raise forms.ValidationError("Please fill out " "one but not both of the zooid " "and gravityspy id fields" ) if zooid and not imageid: if not EventTable.fetch('gravityspy', 'nonanalysisreadyids WHERE links_subjects = {0}'.format(zooid), host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("This zooID is one of a handful of glitches that were mistakenly uploaded, despite being glitches" "occuring while the detector was not in a state to be taking quality data " "(i.e. people may have been working on the instrument at the time." ) if EventTable.fetch('gravityspy', '{0} WHERE links_subjects = {1}'.format(database, zooid), columns=['links_subjects'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("zooid does not exist") elif EventTable.fetch('gravityspy', '{0} WHERE links_subjects = {1} AND ifo IN ({2})'.format(database, zooid, ifos), columns=['links_subjects'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("This image is not from one of the interferometers you selected" ) if imageid and not zooid: if not EventTable.fetch('gravityspy', 'nonanalysisreadyids WHERE \"gravityspy_id\" = \'{0}\''.format(imageid), host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("This gravityspy_id is one of a handful of glitches that were mistakenly uploaded, despite being glitches" "occuring while the detector was not in a state to be taking quality data " "(i.e. people may have been working on the instrument at the time." ) if EventTable.fetch('gravityspy', '{0} WHERE \"gravityspy_id\" = \'{1}\''.format(database, imageid), columns=['gravityspy_id'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("uniqueid does not exist") elif EventTable.fetch('gravityspy', '{0} WHERE \"gravityspy_id\" = \'{1}\' AND ifo IN ({2})'.format(database, imageid, ifos), columns=['gravityspy_id'], host='gravityspyplus.ciera.northwestern.edu').to_pandas().empty: raise forms.ValidationError("This image is not from one of the interferometers you selected" )
def posteriors(request): # if this is a POST request we need to process the form data if request.method == 'GET': # create a form instance and populate it with data from the request: form = PosteriorForm(request.GET) # check whether it's valid: if form.is_valid(): graceid = form.cleaned_data['graceid'] param1 = form.cleaned_data['param1'] param2 = form.cleaned_data['param2'] param1_min = form.cleaned_data['param1_min'] param1_max = form.cleaned_data['param1_max'] param2_min = form.cleaned_data['param2_min'] param2_max = form.cleaned_data['param2_max'] client = GraceDb("https://gracedb-playground.ligo.org/api/") #event = client.event(graceid) #filename = client.files(graceid, 'event.log') ps = EventTable.fetch( 'gravityspy', '\"{0}\"'.format(graceid), selection=[ '{0}<{1}<{2}'.format(param1_min, param1, param1_max), '{0}<{1}<{2}'.format(param2_min, param2, param2_max) ], columns=[param1, param2]) ps = ps.to_pandas().iloc[0:1000] old = 'posteriors' new = 'histogram' histogramurl = (request.get_full_path()[::-1].replace( old[::-1], new[::-1], 1))[::-1] return render( request, 'gracedb.html', { 'results': ps.iloc[0:1000].to_dict(orient='records'), 'histogramurl': histogramurl }) else: return render(request, 'form.html', {'form': form})
def get_imageid_json(name=''): return EventTable.fetch('gravityspy', 'similarity_index_o3 WHERE \"gravityspy_id\" ~ \'{0}\' LIMIT 20'.format(name), columns=["gravityspy_id"], host='gravityspyplus.ciera.northwestern.edu').to_pandas().rename(columns={'gravityspy_id': 'value'}).to_json(orient='records')
import matplotlib.pyplot as plt plt.switch_backend('agg') from gwpy.table import EventTable blips_O2_L1 = EventTable.fetch('gravityspy', 'glitches', selection=[ '"Label" = "Blip"', '1200000000 > "peakGPS" > 1137250000', '"Blip" > 0.95', 'ifo=L1' ]) koi_O2_L1 = EventTable.fetch('gravityspy', 'glitches', selection=[ '"Label" = "Koi_Fish"', '1200000000 > "peakGPS" > 1137250000', '"Koi_Fish" > 0.95', 'ifo=L1' ]) aftercomiss_koi_l1 = koi_O2_L1[koi_O2_L1['peakGPS'] > 1178841618] beforecomiss_koi_l1 = koi_O2_L1[koi_O2_L1['peakGPS'] < 1178841618] beforecomiss_blips_l1 = blips_O2_L1[blips_O2_L1['peakGPS'] < 1178841618] aftercomiss_blips_l1 = blips_O2_L1[blips_O2_L1['peakGPS'] > 1178841618] plot = aftercomiss_blips_l1.hist('snr', logbins=True, bins=50, histtype='stepfilled', label='After Commissioning') ax = plot.gca() ax.hist(aftercomiss_koi_l1['snr'], logbins=True, bins=50, histtype='stepfilled',
def get_gpstimes_json(name=''): return EventTable.fetch('gravityspy', 'similarity_index_o3 WHERE CAST(\"event_time\" AS TEXT) ~ \'{0}\' LIMIT 20'.format(name), columns=["event_time"], host='gravityspyplus.ciera.northwestern.edu').to_pandas().astype(str).rename(columns={'event_time': 'value'}).to_json(orient='records')
def similarity_search(form): # process the data in form.cleaned_data as required if form.cleaned_data['imageid']: uniqueID = str(form.cleaned_data['imageid']) else: uniqueID = form.cleaned_data['imageid'] if form.cleaned_data['zooid']: zooID = float(str(form.cleaned_data['zooid'])) else: zooID = form.cleaned_data['zooid'] if not zooID and not uniqueID: gpstime = float(str(form.cleaned_data['gpstime'])) else: gpstime = False howmany = int(form.cleaned_data['howmany']) engine = create_engine( 'postgresql://{0}:{1}@gravityspy.ciera.northwestern.edu:5432/gravityspy' .format(os.environ['GRAVITYSPY_DATABASE_USER'], os.environ['GRAVITYSPY_DATABASE_PASSWD'])) if zooID: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex WHERE "links_subjects" = \'{0}\'), t AS (SELECT "uniqueID", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex) SELECT "uniqueID", "links_subjects" FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( zooID, howmany) elif uniqueID: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex WHERE "uniqueID" = \'{0}\'), t AS (SELECT "uniqueID", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex) SELECT "uniqueID", "links_subjects" FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( uniqueID, howmany) elif gpstime: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex WHERE "peakGPS" = \'{0}\'), t AS (SELECT "uniqueID", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM similarityindex) SELECT "uniqueID", "links_subjects" FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( repr(gpstime), howmany) # Query Similarity Index to give you the most similar IDs SI = pd.read_sql(PostGresEuclideanDistanceQuery, engine) glitches = EventTable.fetch( 'gravityspy', 'glitches WHERE "uniqueID" IN (\'{0}\')'.format( str("','".join(list(SI['uniqueID'])))), columns=[ 'uniqueID', 'imgUrl1', 'imgUrl2', 'imgUrl3', 'imgUrl4', 'ifo', 'links_subjects', 'snr', 'peak_frequency', 'Label', 'peakGPS', 'Filename1', 'Filename2', 'Filename3', 'Filename4' ]) # Convert from astropy to pandas for easy manipulation SI_glitches = glitches.to_pandas() SI_glitches.loc[SI_glitches.imgUrl1 == '?', 'imgUrl1'] = SI_glitches.loc[SI_glitches.imgUrl1 == '?', ['ifo', 'Filename1']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.imgUrl2 == '?', 'imgUrl2'] = SI_glitches.loc[SI_glitches.imgUrl2 == '?', ['ifo', 'Filename2']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.imgUrl3 == '?', 'imgUrl3'] = SI_glitches.loc[SI_glitches.imgUrl3 == '?', ['ifo', 'Filename3']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.imgUrl4 == '?', 'imgUrl4'] = SI_glitches.loc[SI_glitches.imgUrl4 == '?', ['ifo', 'Filename4']].apply( makelink, axis=1) if zooID: SI_glitches['searchedID'] = SI_glitches.loc[ SI_glitches.links_subjects == zooID, 'uniqueID'].iloc[0] elif gpstime: SI_glitches['searchedID'] = SI_glitches.loc[ SI_glitches.peakGPS == gpstime, 'uniqueID'].iloc[0] else: SI_glitches['searchedID'] = uniqueID if uniqueID: SI_glitches['searchedzooID'] = SI_glitches.loc[ SI_glitches.uniqueID == uniqueID, 'links_subjects'].iloc[0] elif gpstime: SI_glitches['searchedzooID'] = SI_glitches.loc[ SI_glitches.peakGPS == gpstime, 'links_subjects'].iloc[0] else: SI_glitches['searchedzooID'] = zooID return SI_glitches
def calculate_confusion_matrices(self): """Parameters ---------- Returns ------- A dict with keys of workflow IDs and values list of golden sets associated with that workflow """ # Load classifications, and golden images from DB # Make sure choice is a valid index # Make sure to evaluate only logged in users # Ignore NONEOFTHEABOVE classificatios when constructing confusion # matrix # Make sure to the subject classified was a golden image query = 'classificationsdev WHERE \"annotations_value_choiceINT\" != \ -1 AND \"links_user\" != 0 AND \ \"annotations_value_choiceINT\" != 12 AND \ CAST(links_subjects AS FLOAT) IN \ (SELECT \"links_subjects\" FROM goldenimages)' columns = [ 'id', 'links_user', 'links_subjects', 'links_workflow', 'annotations_value_choiceINT' ] classifications = EventTable.fetch('gravityspy', query, columns=columns) classifications = classifications.to_pandas() classifications = classifications.sort_values('id') golden_images = EventTable.fetch('gravityspy', 'goldenimages') golden_images_df = golden_images.to_pandas() # From answers Dict determine number of classes numClasses = len(self.get_answers(workflow=7766).values()[0]) # merge the golden image DF with th classification (this merge is on # links_subject (i.e. the zooID of the image classified) image_and_classification = classifications.merge(golden_images_df, on=['links_subjects']) # This is where the power of pandas comes in...on the fly in very quick # order we can fill all users confusion matrices # by smartly chosen groupby test = image_and_classification.groupby( ['links_user', 'annotations_value_choiceINT', 'GoldLabel']) test = test.count().links_subjects.to_frame().reset_index() # Create "Sparse Matrices" and perform a normalization task on them. # Afterwards determine if the users diagonal # is above the threshold set above confusion_matrices = pd.DataFrame() for iUser in test.groupby('links_user'): columns = iUser[1].annotations_value_choiceINT rows = iUser[1]['GoldLabel'] entry = iUser[1]['links_subjects'] tmp = coo_matrix((entry, (rows, columns)), shape=(numClasses, numClasses)) conf_divided, a1, a2, a3 = \ np.linalg.lstsq(np.diagflat(tmp.sum(axis=1)), tmp.todense()) conf_dict = { 'userID': iUser[0], 'conf_matrix': [conf_divided], 'alpha': [np.diag(conf_divided)] } confusion_matrices = \ confusion_matrices.append(pd.DataFrame( conf_dict, index=[iUser[0]])) self.confusion_matrices = confusion_matrices return confusion_matrices
def similarity_search(form): # process the data in form.cleaned_data as required if form.cleaned_data['imageid']: gravityspy_id = str(form.cleaned_data['imageid']) else: gravityspy_id = form.cleaned_data['imageid'] if form.cleaned_data['zooid']: zooID = float(str(form.cleaned_data['zooid'])) else: zooID = form.cleaned_data['zooid'] if not zooID and not gravityspy_id: gpstime = float(str(form.cleaned_data['gpstime'])) else: gpstime = False howmany = int(form.cleaned_data['howmany']) database = str(form.cleaned_data['database']) ifos = str(form.cleaned_data['ifo']) era = str(form.cleaned_data['era']) engine = create_engine( 'postgresql://{0}:{1}@gravityspyplus.ciera.northwestern.edu:5432/gravityspy' .format(os.environ['GRAVITYSPYPLUS_DATABASE_USER'], os.environ['GRAVITYSPY_DATABASE_PASSWD'])) if zooID: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE "links_subjects" = \'{0}\'), t AS (SELECT "gravityspy_id", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE ifo IN ({3}) AND {4}) SELECT * FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( int(zooID), howmany, database, ifos, era) elif gravityspy_id: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE "gravityspy_id" = \'{0}\'), t AS (SELECT "gravityspy_id", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE ifo IN ({3}) AND {4}) SELECT * FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( gravityspy_id, howmany, database, ifos, era) elif gpstime: PostGresEuclideanDistanceQuery = 'WITH searcharray AS (SELECT cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE "event_time" = \'{0}\'), t AS (SELECT "gravityspy_id", links_subjects, cube(array["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199"]) FROM {2} WHERE ifo IN ({3}) AND {4}) SELECT * FROM t order by (SELECT * FROM searcharray) <-> cube asc limit {1};'.format( repr(gpstime), howmany, database, ifos, era) # Query Similarity Index to give you the most similar IDs SI = pd.read_sql(PostGresEuclideanDistanceQuery, engine) features = SI['cube'].apply(extract_feature_array) features = numpy.vstack(features.values) glitches = EventTable.fetch( 'gravityspy', 'glitches WHERE "gravityspy_id" IN (\'{0}\')'.format( str("','".join(list(SI['gravityspy_id'])))), columns=[ 'gravityspy_id', 'url1', 'url2', 'url3', 'url4', 'ifo', 'links_subjects', 'snr', 'peak_frequency', 'duration', 'central_freq', 'bandwidth', 'ml_label', 'event_time', 'Filename1', 'Filename2', 'Filename3', 'Filename4', 'peak_time' ], host='gravityspyplus.ciera.northwestern.edu') # Convert from astropy to pandas for easy manipulation SI_glitches = glitches.to_pandas() SI_glitches.loc[SI_glitches.url1 == '?', 'url1'] = SI_glitches.loc[SI_glitches.url1 == '?', ['ifo', 'Filename1']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.url2 == '?', 'url2'] = SI_glitches.loc[SI_glitches.url2 == '?', ['ifo', 'Filename2']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.url3 == '?', 'url3'] = SI_glitches.loc[SI_glitches.url3 == '?', ['ifo', 'Filename3']].apply( makelink, axis=1) SI_glitches.loc[SI_glitches.url4 == '?', 'url4'] = SI_glitches.loc[SI_glitches.url4 == '?', ['ifo', 'Filename4']].apply( makelink, axis=1) if zooID: SI_glitches['searchedID'] = SI_glitches.loc[ SI_glitches.links_subjects == zooID, 'gravityspy_id'].iloc[0] elif gpstime: SI_glitches['searchedID'] = SI_glitches.loc[ SI_glitches.event_time == gpstime, 'gravityspy_id'].iloc[0] else: SI_glitches['searchedID'] = gravityspy_id if gravityspy_id: SI_glitches['searchedzooID'] = SI_glitches.loc[ SI_glitches.gravityspy_id == gravityspy_id, 'links_subjects'].iloc[0] elif gpstime: SI_glitches['searchedzooID'] = SI_glitches.loc[ SI_glitches.event_time == gpstime, 'links_subjects'].iloc[0] else: SI_glitches['searchedzooID'] = zooID if zooID: searched_image = features[numpy.argwhere( SI['links_subjects'].values == zooID)][0][0] else: searched_image = features[numpy.argwhere( SI['gravityspy_id'].values == gravityspy_id)][0][0] distances = [] for feature in features: distances.append(1 - distance.cosine(searched_image, feature)) tmp = pd.DataFrame({ 'distances': distances, 'gravityspy_id': SI['gravityspy_id'].values }) SI_glitches = SI_glitches.merge(tmp) return SI_glitches
def get_gpstimes_json(name=''): return EventTable.fetch('gravityspy', 'similarityindex WHERE CAST(\"peakGPS\" AS TEXT) ~ \'{0}\' LIMIT 20'.format(name), columns=["peakGPS"]).to_pandas().astype(str).rename(columns={'peakGPS': 'value'}).to_json(orient='records')
def get_imageid_json(name=''): return EventTable.fetch('gravityspy', 'similarityindex WHERE \"uniqueID\" ~ \'{0}\' LIMIT 20'.format(name), columns=["uniqueID"]).to_pandas().rename(columns={'uniqueID': 'value'}).to_json(orient='records')
def get_zooid_json(name=''): return EventTable.fetch('gravityspy', 'similarity_index_o3 WHERE CAST(links_subjects AS TEXT) ~ \'{0}\' LIMIT 20'.format(name), columns=["links_subjects"], host='gravityspyplus.ciera.northwestern.edu').to_pandas().astype(str).rename(columns={'links_subjects': 'value'}).to_json(orient='records')
def index(request): if request.user.is_authenticated: if request.user.id == 3: other_id = 37 elif request.user.id == 37: other_id = 3 else: other_id = -1 image_to_be_displayed = EventTable.fetch( 'gravityspy', 'retired_images_for_testing WHERE \"gravityspy_id\" NOT IN (SELECT \"gravityspy_id\" FROM label_label WHERE user_id IN (40, {0}, {1})) ORDER BY RANDOM() LIMIT 1' .format(other_id, request.user.id), columns=[ 'url1', 'url2', 'url3', 'url4', 'gravityspy_id', 'ml_label' ], db='gravityspytools', passwd=os.getenv('GRAVITYSPYTOOLS_DATABASE_PASSWD'), user=os.getenv('GRAVITYSPYTOOLS_DATABASE_USER'), host='gravityspyplus.ciera.northwestern.edu') url1 = image_to_be_displayed['url1'] url2 = image_to_be_displayed['url2'] url3 = image_to_be_displayed['url3'] url4 = image_to_be_displayed['url4'] gravityspy_id = list(image_to_be_displayed['gravityspy_id'])[0] retired_label = str(list(image_to_be_displayed['ml_label'])[0]) retired_label = convert_string_labels[retired_label] # Check if this image has already been seen by this user try: does_exist = Label.objects.get(gravityspy_id=gravityspy_id, user=request.user) except: does_exist = False # if it has redirect them to the page for a fresh image # until it is a new label for this user if does_exist: return redirect('/label/') else: if request.method == 'POST': form = LabelForm(request.POST) if form.is_valid(): label = str(form.cleaned_data['label']) agreed = str(form.cleaned_data['agreed']) gravityspy_id = str(form.cleaned_data['gravityspy_id']) classification, created = Label.objects.get_or_create( label=label, agreed=agreed, gravityspy_id=gravityspy_id, user=request.user) classification.save() return redirect('/label/') else: form = LabelForm( initial={ 'label': retired_label, 'agreed': 'AGREE', 'gravityspy_id': gravityspy_id }) return render( request, 'home.html', { 'form': form, 'url1': list(url1)[0], 'url2': list(url2)[0], 'url3': list(url3)[0], 'url4': list(url4)[0], }) else: return redirect(make_authorization_url())