def histc_vega(tensor, min, max, bins): bins = torch.linspace(min, max, bins) hist = tensor.histc(min=bins.min(), max=bins.max(), bins=len(bins)).int() return altair.Chart( altair.Data(values=[ dict(x=b, y=v) for b, v in zip(bins.tolist(), hist.tolist()) ])).mark_bar().encode(x=altair.X('x:Q'), y=altair.Y('y:Q')).to_dict()
def filter_geodata_and_merge( gdf_out: gpd.GeoDataFrame, df_mapping_choro: DataFrame, da_choice: str, right_merge: str, ) -> alt.Data: """ Filter geodata and merge with non-geodata """ # 5. Reset (multi) index from slice of boundary data (if necessary) gdf_out_cols = (["geometry", "community_x", "beat_num_x", "area"] if da_choice == "community_area" else ["geometry", "sector", "beat_num", "area"]) df_right_merge = gdf_out[gdf_out_cols + [right_merge]] df_right_merge = (df_right_merge if da_choice == "neighbourhood" else df_right_merge.reset_index(drop=True)) # 6. INNER JOIN crime and boundary data df_grouped_merged = df_mapping_choro.merge(df_right_merge, left_on=da_choice, right_on=right_merge) # 7. Convert merged data into GeoDataFrame df_map = gpd.GeoDataFrame(df_grouped_merged, geometry="geometry") # display(df_map.head()) # 8. Create data structure for Altair choropleth mapping choro_json = loads(df_map.to_json()) choro_data = alt.Data(values=choro_json["features"]) return choro_data
def geoencode(self) -> alt.Chart: # coverage: ignore """Returns an `altair <http://altair-viz.github.io/>`_ encoding of the shape to be composed in an interactive visualization. """ return alt.Chart(alt.Data(values=self.geojson())).mark_geoshape( stroke="#aaaaaa", strokeWidth=1 )
def on_view(self, file) -> JsonDict: reader = csv.DictReader(file) data = alt.Data(values=list(reader)) return json.loads(alt.Chart(data).mark_bar().encode( x='x:O', # specify ordinal data y='y:Q', # specify quantitative data ).to_json())
def data_to_table(data, step): table = [] try: import torch except ImportError: torch = None if torch is not None and isinstance(data, torch.Tensor): data = data.detach().cpu().numpy() for i in range(data.shape[0]): if len(data.shape) == 2: m = data.shape[1] // 2 row = {'step': data[i, 0], 'v5': data[i, m]} for j in range(1, min(m, 5)): row[f"v{5 - j}"] = data[i, m - j] row[f"v{5 + j}"] = data[i, m + j] elif step is not None: row = {'step': step[i], 'v5': data[i]} else: row = {'step': i, 'v5': data[i]} table.append(row) return alt.Data(values=table)
def read_minsal_table(): ''' reads a table with latest data on confirmed cases, by region ''' URL = 'https://www.minsal.cl/nuevo-coronavirus-2019-ncov/casos-confirmados-en-chile-covid-19/' minsal = pd.read_html(URL)[0].iloc[2:] minsal.columns = minsal.iloc[0] minsal = minsal.iloc[1:-1] minsal['codregion'] = [15, 1, 2, 3, 4, 5, 13, 6, 7, 16, 8, 9, 14, 10, 11, 12] ### reads shapefile with chilean regions # URL = 'https://www.bcn.cl/obtienearchivo?id=repositorio/10221/10398/2/Regiones.zip' # regions = geopandas.read_file(URL) shape = 'data/Regional' regions = geopandas.read_file(shape) regions = regions.merge(minsal, on='codregion') choro_json = json.loads(regions.to_json()) choro_data = alt.Data(values=choro_json['features']) return choro_data
def marginals_altair(fanova): """Outputs the marginal effect of each hyper-parameter according to FANOVA Parameters ---------- fanova: FANOVA instance of FANOVA class Examples -------- .. image:: ../../../docs/_static/plots/marginals.png """ import altair as alt alt.themes.enable('dark') data = fanova.compute_marginals() marginals = alt.Data(values=data) base = alt.Chart(marginals).encode(alt.X('value', type='quantitative'), alt.Y('objective', type='quantitative'), yError='std:Q', color='name:N').properties(width=200, height=200) chart = (base.mark_errorband() + base.mark_line())\ .facet(column='name:N').interactive() return chart
def prepare_for_altair(attribute_column, geography, chloropleth, pickle_dir='data/pickles'): df = merge_data(attribute_column, geography, chloropleth, pickle_dir) gdf = gpd.GeoDataFrame(df, crs={'init' :'epsg:4326'}, geometry='geometry') gdf = gdf[['key', 'category', attribute_column, 'geometry']] json_gdf = gdf.to_json() json_features = json.loads(json_gdf) return alt.Data(values=json_features['features'])
def _rankingmap_altair(countries, ranking, x, scenario=None, method='number', title='', label=''): # Adapted from https://altair-viz.github.io/gallery/index.html import pandas as pd import altair as alt if method not in ['number', 'value']: raise ValueError('method must be "number" or "value"') source = alt.Data(values=countries) if ranking.plot_type == 'indicator_vs_temperature': details = 'warming level: {} {}'.format(x, ranking.plot_unit_x) else: details = 'period: {}, scenario: {}'.format( x, { 'rcp26': 'RCP 2.6', 'rcp45': 'RCP 4.5', 'rcp60': 'RCP 6', 'rcp85': 'RCP 8.5' }.get(scenario, scenario)) default_title = getattr(ranking, 'plot_label_y', '') + '\n' + details # default_label = 'ranking number' if method == 'number' else ('ranking value ({})'.format(getattr(ranking, 'plot_unit_y'))) ranking_data = get_ranking_data(countries, ranking, x, scenario, method) chart = alt.Chart(source).mark_geoshape().encode( # color="Rank:Q", color=alt.Color("Rank:Q", sort='ascending') if method == 'number' else alt.Color("Value:Q", sort='descending'), # tooltip=["Country:N", "Code:N", "Value:Q", "Rank:Q"] tooltip=[ "label:N", "unit:N", "Country:N", "Code:N", "Value:Q", "Rank:Q" ]).transform_lookup(lookup='properties.ISIPEDIA', from_=alt.LookupData(ranking_data, 'Code', ranking_data.columns.tolist()) ).project('naturalEarth1').properties( width=800, autosize=alt.AutoSizeParams(contains="padding", type="fit-x"), title=ranking.plot_title # ).configure_view(stroke=None ).configure(background='#F1F4F4').configure_title( fontSize=16, ).configure_axis( labelFontSize=14, titleFontSize=16, ).configure_legend( titleFontSize=14, labelFontSize=14, ).configure_mark(fontSize=14) # ).interactive() return chart
def scatter_matrix_altair(configs, columns, color='epoch'): """Plots hyper-parameter space exploration Parameters ---------- configs: List[dict] A list of configuration tried by the hyper-parameter columns: List[str] A list of the hyper-parameters color: str Dimension to use to color each points Examples -------- >>> columns = ['a', 'b', 'c'] >>> data = [ ... dict(a=1, b=2, c=3, epoch=1), ... dict(a=2, b=1, c=1, epoch=2), ... dict(a=3, b=3, c=2, epoch=3), ... ] >>> chart = scatter_matrix_altair(data, columns, color='epoch') .. image:: ../../../docs/_static/plots/space_exploration.png """ import altair as alt alt.themes.enable('dark') from olympus.dashboard.plots.utilities import AltairMatrix space = alt.Data(values=configs) base = alt.Chart().properties(width=120, height=120) def scatter_plot(row, col): """Standard Scatter plot""" return base.mark_circle(size=5).encode( alt.X(row, type='quantitative'), alt.Y(col, type='quantitative'), color=f'{color}:N').interactive() def density_plot(row): """Estimate the density function using KDE""" return base.transform_density(row, as_=[row, 'density' ]).mark_line().encode(x=f'{row}:Q', y='density:Q') def histogram_plot(row): """Show density as an histogram""" return base.mark_bar().encode(alt.X(row, type='quantitative', bin=True), y='count()') return (AltairMatrix(space).fields(*columns) # .upper(scatter_plot) .diag(histogram_plot).lower(scatter_plot)).render()
def get_distribution() -> Any: scores = models.get_statistics_scores() data = alt.Data(values=[dict(score=score) for score in scores]) return (alt.Chart(data).mark_bar().encode( x=alt.X("score:O", bin=True, axis=alt.Axis(title="package score")), y=alt.Y("count()", axis=alt.Axis(title="count")), ).configure_axis(grid=False).properties(width=600, height=400).to_json())
def geoencode(self, **kwargs) -> alt.Chart: # coverage: ignore """Returns an `altair <http://altair-viz.github.io/>`_ encoding of the shape to be composed in an interactive visualization. Specific plot features, such as line widths, can be passed via **kwargs. See `documentation <https://altair-viz.github.io/user_guide/marks.html>`_. """ return alt.Chart(alt.Data(values=self.geojson())).mark_geoshape( stroke="#aaaaaa", **kwargs)
def prepare_for_altair(self, df=None, file_name=None, processed_dir=cn.CSV_DIR): df = self.merge_data(df, file_name, processed_dir) gdf = gpd.GeoDataFrame(df, crs=cn.CRS_EPSG, geometry=cn.GEOMETRY) json_gdf = gdf.to_json() json_features = json.loads(json_gdf) return alt.Data(values=json_features['features'])
def __data_to_table(self, data): table = [] for i in range(data.shape[0]): row = {'step': data[i, 0]} for j in range(1, 10): row[f"v{j}"] = data[i, j] table.append(row) return alt.Data(values=table)
def data_to_table(data: np.ndarray, x_data: np.ndarray): table = [] for i in range(data.shape[0]): if len(data.shape) == 2: # Distribution row = {'x': x_data[i, 5], 'y': data[i, 5]} else: row = {'x': x_data[i], 'y': data[i]} table.append(row) return alt.Data(values=table)
def package_score_reports_to_scores_histogram( reports: Iterable[models.PackageReport], ) -> alt.Chart: """ Returns a vega spec and data to render a histogram of the distribution of scores for the provided package score reports """ data = alt.Data(values=[dict(score=report.score) for report in reports]) return (alt.Chart(data).mark_bar().encode( x=alt.X("score:O", bin=True, axis=alt.Axis(title="package score")), y=alt.Y("count()", axis=alt.Axis(title="count")), ))
def chart_obj(request): h_list = Homicide.objects.annotate(c=Count('count')).values( 'age', 'c', 'gender') data = alt.Data(values=list(h_list)) chart = alt.Chart(data, height=300, width=300, title='Age / Gender').mark_circle().encode( alt.X('age:Q', bin=True), alt.Y('gender:N'), alt.Size('sum(c):Q', title='Counts'), color='sum(c):Q') return JsonResponse(chart.to_dict(), safe=False)
def altair_example(): import altair as alt data = alt.Data(values=[{'x': 'A', 'y': 5}, {'x': 'B', 'y': 3}, {'x': 'C', 'y': 6}, {'x': 'D', 'y': 7}, {'x': 'E', 'y': 2}]) chart = alt.Chart(data).mark_bar().encode( x='x:O', # specify ordinal data y='y:Q', # specify quantitative data ) return chart
def unit_count_through_time(): with open('/home/setepenre/work/LuaFun/botscpp/unit_size.txt', 'r') as f: data = [dict(x=i, y=int(r)) for i, r in enumerate(f.readlines())] data = alt.Data(values=data) chart = alt.Chart(data).mark_line().encode( x='x:Q', y='y:Q', ) chart.save('unitcount.png', webdriver='firefox')
def chart_stack(request): h_list = Homicide.objects.annotate( month=TruncMonth('date')).values('month').annotate( ct=Count('count')).values('month', 'ct', 'gender') data = alt.Data(values=list(h_list)) chart = alt.Chart(data, height=300, width=300, title='Month Count by Gender').mark_bar(size=30).encode( x='month:T', y='ct:Q', color='gender:N').interactive() return JsonResponse(chart.to_dict(), safe=False)
def chart_suspect(request): h_list = Homicide.objects.annotate(ct=Count('count')).values( 'ethnicity', 'killerethnicity', 'ct').annotate(s=Sum('ethnicity')) data = alt.Data(values=list(h_list)) chart = alt.Chart(data, height=300, width=300, title='Culprit vs Victim').mark_rect().encode( alt.X('ethnicity:N', title='victim ethnicity'), alt.Y('killerethnicity:N', title='culprit ethnicity'), color='ct:Q', tooltip=['ct:Q']).interactive() return JsonResponse(chart.to_dict(), safe=False)
def chart_cod(request): h_list = Homicide.objects.values('means', 'gender') data = alt.Data(values=list(h_list)) chart = alt.Chart(data, height=300, width=300, title='CoD - Cause of Death').mark_bar().encode( alt.X('means:N', title='Cause (G)un, (O)ther, (S)tabbing'), alt.Y('count(means):Q', title='Count'), color='gender:N', tooltip=['count(means):Q']) return JsonResponse(chart.to_dict(), safe=False)
def my_cool_chart_view(req): # import ipdb; ipdb.set_trace() query = Solution.objects.all().values() data = alt.Data(values=list(query)) chart_obj = alt.Chart(data).mark_bar().encode( alt.Y("sector:N"), alt.X('co2_reduction:Q'), alt.Color("solution:N", legend=None, scale=alt.Scale(scheme='tableau20')), tooltip=["solution:N", 'co2_reduction:Q']) # import ipdb; ipdb.set_trace() return JsonResponse(chart_obj.to_dict(), safe=False)
def main(): from luafun.train.metrics import MetricWriter from luafun.utils.options import datapath from luafun.model.components import HeroEmbedding import luafun.game.constants as const uid = 'ea844d250dfa4137a8c386972424939c' writer = MetricWriter(datapath('metrics'), uid) hero_encoder = HeroEmbedding(128) henc = writer.load_weights('henc') hero_encoder.load_state_dict(henc) # ==== Done loading the model weight = list(hero_encoder.baseline.parameters())[0] print(weight.shape) viz = VizEmbeddingSpace() proj, var = viz.pca_torch(weight) # proj, var = viz.pca_manual(weight) print(var) print(proj.shape) points = [] for i in range(122): x, y, z = proj[i, :] * 100 hero = const.HERO_LOOKUP.from_offset(i) name = hero.get('pretty_name', hero.get('alias', hero.get('name'))) points.append(dict(x=x.item(), y=y.item(), z=z.item(), name=name)) import altair as alt alt.themes.enable('dark') # .mark_point().encode( # x='x:Q', # y='y:Q', # color='z:Q', # text='name:N' # ) chart = alt.Chart(alt.Data(values=points)).mark_text().encode( x='x:Q', y='y:Q', color='z:Q', text='name:N' ).properties( width=1980 * 0.75, height=1080 * 0.75 ).interactive() chart.save('chart_2.html')
def merge_geodata(data): """ Create the geospacial data :param data: :return: """ gdf = get_geodata() gdf = gdf.merge(data, left_on='iso_a3', right_on='CountryCode', how='inner') # Convert the geodata to json choro_json = json.loads(gdf.to_json()) final_geo_data = alt.Data(values=choro_json['features']) return final_geo_data
def test_chart(self): qs = Sale.objects.all().values('date', 'amount', 'payment_method') data = alt.Data(values=list(qs)) chart = alt.Chart(data).mark_bar().encode(x='date:T', y='amount:Q', color='payment_method:N', column='payment_method:N') output = render(chart.to_dict()) pathlib.Path('test.svg').write_text(output['svg']) pathlib.Path('test.png').write_bytes(base64.b64decode(output['png']))
def importance_heatmap_altair(fanova): """Outputs the importance of each hyper-parameter according to FANOVA Parameters ---------- fanova: FANOVA instance of FANOVA class Examples -------- >>> from olympus.dashboard.analysis.hpfanova import FANOVA >>> import pandas as pd >>> data = [ ... dict(objective=0.12 / 0.08, uid=0, epoch=32, hp1=0.12, hp2=0.08), ... dict(objective=0.14 / 0.09, uid=0, epoch=32, hp1=0.14, hp2=0.09), ... dict(objective=0.15 / 0.10, uid=0, epoch=32, hp1=0.15, hp2=0.10), ... dict(objective=0.16 / 0.11, uid=0, epoch=32, hp1=0.16, hp2=0.11), ... dict(objective=0.17 / 0.12, uid=0, epoch=32, hp1=0.17, hp2=0.12) ... ] >>> space = { ... 'hp1': 'uniform(0, 1)', ... 'hp2': 'uniform(0, 1)' ... } >>> data = pd.DataFrame(data) >>> fanova = FANOVA( ... data, ... hp_names=list(space.keys()), ... objective='objective', ... hp_space=space) >>> chart = importance_heatmap_altair(fanova) .. image:: ../../../docs/_static/plots/importance.png """ import altair as alt alt.themes.enable('dark') data = alt.Data(values=fanova.importance_long) base = alt.Chart(data).mark_rect().encode(x='row:O', y='col:O').properties(width=200, height=200) chart = alt.concat( base.encode(color='importance:Q'), base.encode(color='std:Q')).resolve_scale(color='independent') return chart
def chart_heat(request): h_list = Homicide.objects.annotate(ct=Count('count')).values( 'ethnicity', 'gender', 'age', 'ct') data = alt.Data(values=list(h_list)) chart = alt.Chart( data, height=300, width=300, title='Age vs Ethnicity').mark_rect().encode( alt.X('ethnicity:N', title='ethnicity'), alt.Y('age:N', title='age', bin=True), color=alt.Color('sum(ct):Q', scale=alt.Scale(domain=['1', '25', '50'], range=['yellow', 'red', 'black'])), tooltip=['sum(ct):Q']).interactive() return JsonResponse(chart.to_dict(), safe=False)
def map(business_to_choose="Beauty Salon"): """ Given the business type and year, filter the dataset and plot a map for the counts of the buisness per neighbourhood parameters -------------------- business_to_choose: (str) type of business to filter the dataset year_to_choose: (int) year to filter the dataset returns --------------------- an altair map. """ dataset = pd.read_csv("Data/dataset.csv").dropna()[[ "FOLDERYEAR", "LicenceRSN", "LocalArea", "Business_type_pp", "X", "Y" ]] dataset_subset = dataset.query("Business_type_pp == @business_to_choose") url = "https://maps.vancouver.ca/server/rest/services/Hosted/NeighbourhoodBoundaries/FeatureServer/0/query?outFields=*&where=1%3D1&f=geojson" # Vancouver Map Json file r = requests.get(url) file = r.json() background_data = alt.Data(values=file['features']) # Vancouver Background background = alt.Chart(background_data).mark_geoshape( fill='lightgray', stroke='white').encode().properties(width=500, height=300) # Obtaining the mean coordinates per LocalArea dataset_subset_grouped = dataset_subset.groupby(by="LocalArea").aggregate({ "LicenceRSN": 'count', "X": "mean", "Y": "mean" }).reset_index() points = alt.Chart(dataset_subset_grouped).mark_circle().encode( longitude='X:Q', latitude='Y:Q', size=alt.Size('LicenceRSN:Q', title='Number of ' + business_to_choose), color=alt.value('steelblue'), tooltip=[ "LocalArea", "LicenceRSN" ]).properties(title='Number of ' + business_to_choose + ' Registered Businesses in Vancouver per Neighbourhood') return background + points
def test_chart_data(): data = pd.read_csv(CSV_URL) # sanity check assert data.equals(pd.read_json(JSON_URL)) chart1 = altair.Chart(data) chart2 = altair.Chart(CSV_URL) chart3 = altair.Chart(JSON_URL) # TODO: test layered charts data_by_value = altair.Data(values=data.to_dict(orient='records')) for datatype in [data, CSV_URL, JSON_URL, data_by_value]: chart = altair.Chart(datatype) assert data.equals(chart_data(chart))