def get_val(dicty,key,ols=False):
if key in dicty.keys():
val = dicty[key]
if isinstance(val,dict):
out = []
for key, value in val.items():
val = str(value)
if ols:
linkout = "https://www.ebi.ac.uk/ols/search?q={}&exact=on".format(val)
out.append(html.Div([ html.Em(key + ": "), html.A(href=linkout, children=val, target="_blank")]))
else:
out.append(html.Div([ html.Em(key + ": "), html.Span(val)]))
elif isinstance(val,list):
out = []
for v in val:
if isinstance(v,dict):
outi = []
for key, value in v.items():
val = str(value)
if ols:
linkout = "https://www.ebi.ac.uk/ols/search?q={}&exact=on".format(val)
outi.append(html.Div([ html.Em(key + ": "), html.A(href=linkout, children=val, target="_blank")]))
else:
outi.append(html.Div([ html.Em(key + ": "), html.Span(val)]))
else:
out = str(v)
out.append(html.Div(outi))
else:
out = str(val)
return html.Div(out)
else:
return "undefined"
def get_lyric_snippet(song_data):
lyric_row = []
lyric_snippet = [
snippet for snippet in song_data["lyric_snippet"][:100].split("|")
if snippet
]
for i, lyric in enumerate(lyric_snippet):
if i < len(lyric_snippet) - 1:
lyric_row += [html.Small(html.Em(lyric)), html.Br()]
else:
lyric_row.append(html.Small(html.Em(lyric + "...")))
return lyric_row
def display_click_data(clickData, word, compare_word, mapscope):
import json
import re
try:
limit = clickData['points'][0]['text'].split('<br>')[0]
except:
return html.Ul(html.Li(html.Em("Nothing selected")))
if compare_word and compare_word.strip() != '':
word = word + "," + compare_word
q = word.split(",")
bw_html.search_limits = {'publication_' + mapscope: [limit], 'word': q}
results = bw_html.run()
# Format results
links = []
for result in results.json():
try:
groups = re.search("href=(.*)><em>(.*?)</em> \((.*?)\)",
result).groups()
link = html.Li(
html.A(href=groups[0],
target='_blank',
children=["%s (%s)" % (groups[1], groups[2])]))
links.append(link)
except:
raise
return html.Ul(links)
def render_article_content(pathname):
if pathname == '/':
return [
html.H2('博客列表：'),
html.Div(
id='article-links',
style={
'width': '100%'
}
)
]
elif pathname.startswith('/article-'):
response = requests.get('https://www.cnblogs.com/feffery/p/%s.html' % re.findall('\d+', pathname)[0])
tree = etree.HTML(response.text)
return (
html.H3(tree.xpath("//title/text()")[0].split(' - ')[0]),
html.Em('作者：费弗里'),
dash_dangerously_set_inner_html.DangerouslySetInnerHTML(
unescape(etree.tostring(tree.xpath('//div[@id="cnblogs_post_body"]')[0]).decode())
)
)
return dash.no_update
def __layout_quote(quote: str) -> html.Div:
return html.Div(
className="container",
children=[
html.Hr(),
html.H3([html.Em('"{}"'.format(quote))]),
html.Hr(),
],
)
def colour_code_table():
rows = []
rows.append(html.Tr([html.Td(children="Reviewed/threshold",className="tr-done-threshold"),html.Td(children="You reviewed pattern, and 5+ community reviews overall")]))
rows.append(html.Tr([html.Td(children="Reviewed/not threshold",className="tr-done-notthreshold"),html.Td(children="You reviewed pattern, but there are less than 5 community reviews overall")]))
rows.append(html.Tr([html.Td(children="Not reviewed/threshold",className="tr-notdone-threshold"),html.Td(children="You have not reviewed pattern, but 5+ community reviews overall")]))
rows.append(html.Tr([html.Td(children="Not reviewed/not threshold",className="tr-notdone-notthreshold"),html.Td(children="You have not reviewed pattern, and there are less than 5 community reviews overall")]))
return html.Div([
html.Hr(),
html.Em("Colour coding: "),
html.Table(
rows
)])
def similarity_tab_details(skills_gap):
similarity_list = skills_gap["OccupationSkillsMatchList"]
details = []
if similarity_list is None:
details.append(html.P(html.Em("No data available")))
return details
for similarity in similarity_list:
details.append(
html.P(children=[
html.Strong(similarity["Title"]),
html.Br(), similarity["Description"]
]))
return details
def refresh_message_board(n_clicks, nickname, message):
if nickname and message:
submit_new_message(nickname, message)
return [
html.Div(
[
html.Strong(record['nickname']),
html.Span(' '),
html.Em(record['pub_datetime'].strftime(format='%Y-%m-%d %H:%M:%S')),
html.Br(),
html.P(record['message_content'])
]
)
for record in fetch_all_message()
]
def differences_tab_details(skills_gap, OnetCodeSource, OnetCodeTarget):
differences_list = skills_gap["OccupationSkillsGapList"]
details = []
if differences_list is None:
details.append(html.P(html.Em("No data available")))
return details
for difference in differences_list:
details.append(
html.P(children=[
html.Strong(difference["Title"]),
html.Br(), difference["Description"]
]))
details.append(
difference_graph(OnetCodeSource, OnetCodeTarget,
difference["SkillId"]))
return details
def _new_dashboard() -> html.Div:
return html.Div([
html.Div([
_upload_component("compliance-report", "Compliance Assistant Report"),
_upload_component("training-report", "Training Assistant Report"),
], className="upload-group"),
html.Span("Dashboard Report Title (e.g. County Team, Whole Region)"),
dcc.Input(
id="input-title",
type="text",
persistence=True,
),
html.Span("Percentage of valid disclosures from Compass Disclosure Management Report (e.g. 98.5)"),
html.Em("Please type only the number and not a percentage sign etc."),
dcc.Input(
id="input-disclosures",
type="number",
persistence=True,
min=0, max=100, step=0.1,
),
html.Button("Create Report", id="button"),
html.Div(hidden=True, id="new-dashboard-warnings")
], className="page-container app-container new-dash")
def get_zip_click_card(feature):
header_style = {"fontSize": "1.5em", "fontWeight": "bold"}
if feature is not None:
header_text = html.Span(
f"ZIP Code {feature['properties']['ZCTA5CE10']}",
style=header_style)
body_contents = [
html.Strong(
"Total funds contributed for Mayor's race (all candidates): "),
html.Span(
locale.currency(feature["properties"]["total_mayor_donations"],
grouping=True)),
]
else:
header_text = html.Span(f"No ZIP Selected")
body_contents = [html.Em("No info to display")]
card_content = [
dbc.CardHeader([
header_text,
dbc.Button(
" X ",
outline=True,
color="danger",
id="zip-box-close",
style={"float": "right"},
),
]),
dbc.CardBody(body_contents),
]
zip_card = dbc.Card(card_content,
color="dark",
outline=True,
id="floatbox")
return zip_card
def display_click_data(clickData, word_query, facet):
import re
word_query = json.loads(word_query)
word = word_query['word']
compare_word = word_query['compare']
try:
facet_value_select = clickData['points'][0]['y']
year_select = int(clickData['points'][0]['x'])
except:
return html.Ul(html.Li(html.Em("Nothing selected")))
if compare_word and compare_word.strip() != '':
word = word + "," + compare_word
q = word.split(",")
bw_html.search_limits = {
facet: [facet_value_select],
'date_year': year_select,
'word': q
}
results = bw_html.run()
# Format results
links = []
for result in results.json():
try:
groups = re.search("href=(.*)><em>(.*?)</em> \((.*?)\)",
result).groups()
link = html.Li(
html.A(href=groups[0],
target='_blank',
children=["%s (%s)" % (groups[1], groups[2])]))
links.append(link)
except:
raise
print(links)
return html.Ul(links)
return "None"
df["Ratio"] = df.apply(agg_func, axis=1)
df["About"] = df.apply(about_func, axis=1)
fig = px.line(df, x="Timeframe", y="Counts (31 counters)", color="Year", labels ={
"Counts (31 counters)":"Trail Users",
"Timeframe":"Week"
})
fig_2_text = html.Div([
html.H4("Key Findings"),
html.P(html.Em("Click on our findings to see them highlighted in the chart.")),
dbc.Button(
html.Div([
html.H5("Walkers outnumber bikers..."),
html.P("In 58 weeks out of the 92 weeks observed walkers outnumbered bikers.")
]),
id="button-1", className="mb-2 mr-3 mt-3", color="light"),
dbc.Button(
html.Div([
html.H5("In 2019.."),
html.P("In 2019 bikers only outnumbered walkers on 13 out of the 46 weeks observed. Walkers seemed to own the trails.")
]),
id="button-2", className="mt-2 mr-3", color="light"),
dbc.Button(
html.Div([
html.H5("But...In 2020 bikers are catching up!"),
def make_detail_header(filter_data, suff=""):
"""
Return a card with the date selection and buttons in the header, and a table in the body with filter selections
"""
log("make_detail_header")
if suff == "":
color = 'primary'
elif suff == "2":
color = 'success'
direction = filter_data['direction']
stations = "All" if filter_data['stations'] is None else ", ".join(
filter_data['stations'])
if (filter_data['cats'] is None) or (len(set(filter_data['cats'])) >= len(
set(memtypes))):
cats = "All"
else:
cats = ", ".join(filter_data['cats'])
date = ' ' if filter_data['date'] is None else filter_data['date']
date_button = dbc.Button(
id=f"date-update-btn{suff}",
outline=True,
className='rounded-0',
color='link',
children=[html.Span(className="fa fa-calendar text-white")])
#date_button = dcc.Link(href="#",id=f"date-update-btn{suff}",children=html.Span(className="fa fa-calendar"))
date_button_tt = dbc.Tooltip(target=f"date-update-btn{suff}",
children="Change the current date range")
close_button = dbc.Button(
id=f"close-btn{suff}",
outline=True,
className='rounded-0',
color='link',
children=[html.Span(className="fa fa-times-circle text-white")])
close_button_tt = dbc.Tooltip(target=f"close-btn{suff}", children="Close")
if suff == "":
date_button2 = dbc.Button(
id='date-button2',
outline=True,
className='rounded-0',
color='link',
children=[html.Span(className="fa fa-plus text-white")])
date_button2_tt = dbc.Tooltip(target='date-button2',
children="Compare a second date range")
close_button = dbc.Button(
id=f"close-btn{suff}",
className='d-none',
color='link',
children=[html.Span(className="fa fa-times-circle text-white")])
else:
date_button2 = ""
date_button2_tt = ""
data_button = dbc.Button(
id=f'data-button{suff}',
outline=True,
className='rounded-0',
color='link',
children=[html.Span(className="fa fa-table text-white")])
data_button_tt = dbc.Tooltip(target=f'data-button{suff}',
children="View raw data")
if len(date) == 2:
d1 = dt.datetime.strptime(date[0],
'%Y-%m-%d').strftime('%A, %B %-d %Y')
d2 = dt.datetime.strptime(date[1],
'%Y-%m-%d').strftime('%A, %B %-d %Y')
header_txt = dbc.Col(
[d1, " ",
html.Span(className="fa fa-arrow-right"), " ", d2])
else:
d1 = dt.datetime.strptime(date, '%Y-%m-%d').strftime('%A, %B %-d %Y')
header_txt = dbc.Col(children=[d1])
header = dbc.Row(className='',
children=[
header_txt, date_button, date_button_tt, data_button,
data_button_tt, date_button2, date_button2_tt,
close_button, close_button_tt
])
radio_class = 'd-none' if stations == 'All' else ''
radio = dbc.RadioItems(id=f'stations-radio{suff}',
className=radio_class,
options=[{
'label': 'Trip Start',
'value': 'start'
}, {
'label': 'Trip End',
'value': 'stop'
}, {
'label': 'Both',
'value': 'both'
}],
value=direction,
inline=True)
return_btn_class = 'd-none' if stations == 'All' else ''
return_btn_tt = dbc.Tooltip("Go back to all stations",
target=f'map-return-btn{suff}')
return_btn = dbc.Button(
size="sm",
className=return_btn_class,
id=f'map-return-btn{suff}',
color='white',
children=[html.Span(className=f"fa fa-times-circle text-{color}")])
stations_div = dbc.Row([
dbc.Col([html.Em(stations), return_btn_tt, return_btn]),
dbc.Col([radio])
])
stations_header_tt = dbc.Tooltip("Select a station by clicking on the map",
target=f'stations-header-icon{suff}')
membership_header_tt = dbc.Tooltip(
"Select membership types when choosing a date range",
target=f'membership-header-icon{suff}')
stations_header_text = html.Div([
"Stations ",
html.Span(id=f'stations-header-icon{suff}',
className=f"fa fa-question-circle text-{color}")
])
membership_header_text = html.Div([
"Membership Types ",
html.Span(id=f'membership-header-icon{suff}',
className=f"fa fa-question-circle text-{color}")
])
row3 = html.Tr([
html.Th(
html.Span(id=f'stations-header{suff}',
children=stations_header_text)),
html.Td(stations_div), stations_header_tt
])
row4 = html.Tr([
html.Th(
html.Span(id=f'membership-header{suff}',
children=membership_header_text)),
html.Td(html.Em(cats)), membership_header_tt
])
table_body = [html.Tbody([row3, row4])]
table = dbc.Table(table_body, size='sm', bordered=False)
card = dbc.Card(
className='mb-3',
children=[
dbc.CardHeader(className=f"font-weight-bold text-white bg-{color}",
children=header),
table,
])
log("make_detail_header finished")
return card
def home_layout():
layout = html.Div([
html.Div("Not intended for public use at this time",
style={
'color': 'red',
'font-weight': 'bold',
'text-align': 'center'
}),
html.Div("Internal collaborators only. Please report bugs :)",
style={'text-align': 'center'}),
html.Br(),
html.Details([
html.Summary(
html.H5("What is propnet?",
style={
'display': 'inline-block',
'vertical-align': 'middle'
})),
dcc.Markdown("""
Property data and relationships between properties are the fundamental bases of scientific knowledge.
These building blocks connect to form a web or graph of knowledge that can traverse different scientific domains.
_propnet_ is a Python-based software package which allows users to explore and expand datasets of materials properties
using fundamental and literature-sourced relationships between properties across knowledge domains.
In _propnet_, we have codified these properties and relationships with the following goals:
"""),
html.Ul([
html.Li("Connect knowledge domains through common properties",
style={'margin-bottom': 0}),
html.Li(
"Uncover \"hidden\" information in datasets by deriving " +
"new properties from known relationships and data",
style={'margin-bottom': 0}),
html.
Li("Explore new relationships and correlations between properties",
style={'margin-bottom': 0})
])
]),
html.Details([
html.Summary(
html.H5("What is on this website?",
style={
'display': 'inline-block',
'vertical-align': 'middle'
})),
dcc.Markdown("""
The purpose of this site is to demonstrate some of the features available in the _propnet_ package:
"""),
html.Ul([
html.Li(html.P([
html.B("Explore"),
" allows you to see what properties (symbols) and "
"models are currently built into ",
html.Em("propnet"), " (as of the last website build)."
],
style={'display': 'inline'}),
style={'margin-bottom': 0}),
html.Li(html.P([
html.B("Generate"),
" allows you to run the graph traversal algorithm "
"on your own data or data imported from ",
html.A("Materials Project",
href="https://materialsproject.org"), " or ",
html.A("AFLOW", href="http://aflowlib.org"), "."
],
style={'display': 'inline'}),
style={'margin-bottom': 0}),
html.Li(html.P([
html.B("Correlate"),
" allows you to explore different metrics used to "
"correlate scalar properties calculated from MP data."
],
style={'display': 'inline'}),
style={'margin-bottom': 0}),
html.Li(html.P([
html.B("Plot"),
" allows you to plot two, three, or four scalar "
"properties against one another. This information pairs with Correlate data."
],
style={'display': 'inline'}),
style={'margin-bottom': 0}),
html.Li(html.P([
html.B("References"),
" shows citations for our database data and for some of "
"our key analysis/retrieval packages."
],
style={'display': 'inline'}),
style={'margin-bottom': 0})
])
]),
html.Details([
html.Summary(
html.H5("How can I apply propnet to my own data?",
style={
'display': 'inline-block',
'vertical-align': 'middle'
})),
dcc.Markdown("""
A design goal of this project is to make it easily accessible for scientists who aren't coding experts.
Please see our [demo notebook](https://github.com/materialsintelligence/propnet/blob/master/demo/Getting%20Started.ipynb)
for a step-by-step example of how to apply _propnet_ to your own data. If you have a Materials Project API key,
you can also apply _propnet_ to an MP material.
""")
]),
html.Details([
html.Summary(
html.H5("How powerful is propnet?",
style={
'display': 'inline-block',
'vertical-align': 'middle'
})),
dcc.Markdown("""
To demonstrate the power of propnet, we connected it to the materials in the Materials Project database.
Applying our graph traversal algorithm, we were able to expand the total number of known properties
by over 300%.
As the code base grows with more models and properties, more data can be derived! We welcome suggestions or
contributions of models and properties (symbols). Please contact us via our GitHub page (linked below).
""")
]),
html.Details([
html.Summary(
html.H5("Where can I download the code or make a suggestion?",
style={
'display': 'inline-block',
'vertical-align': 'middle'
})),
dcc.Markdown("""
Our GitHub repository is available [here](https://github.com/materialsintelligence/propnet).
If you would like to test _propnet_ locally, please clone the repository, `pip install -r requirements.txt`
and `python setup.py develop`.
If you have a suggestion for a feature or for a model, please open an issue or contact the team via GitHub.
""")
]),
html.Br(),
html.Div(
"Funded by Accelerated Materials Design and Discovery, Toyota Research Institute",
style={
'text-align': 'center',
'font-size': "1rem"
})
])
return layout
dfs,
"Tasa incidencia acumulada día cero",
)),
lg=6,
),
]
return figures
app.layout = dbc.Container(
[
html.H1("Información epidemiológica Covid - 19"),
html.Hr(),
html.P([
"Última actualización el ",
html.Em(max_date, id="date"),
" desde la ",
html.A(
"Comunidad de Madrid",
href=
"https://datos.comunidad.madrid/catalogo/dataset/covid19_tia_zonas_basicas_salud",
),
]),
html.P([
"Mapa disponible ",
html.A(
"aquí",
href=
"https://comunidadmadrid.maps.arcgis.com/apps/PublicInformation/index.html?appid=7db220dc2e0a40b4a928df661a89762e",
),
]),
style=dict(border="1px solid #ccc",
borderRadius="4px",
fontSize="13px",
height="200px",
padding="8px 10px",
resize="none",
width="100%"))
],
style=dict(flex=.5, marginRight="25px")),
html.Figure(id="prediction", style=dict(flex=.5, marginLeft="25px"))
],
style=dict(display="flex")),
html.H2("Influential Words"),
html.P([
"To identify words that heavily contribute to the above prediction, we define a word's ",
html.Em("contribution"), " to a genre's prediction as the product of:"
],
style=dict(marginBottom="0")),
html.Ol([
html.Li("The model coefficient corresponding to the word and genre."),
html.Li("The input's TF-IDF value corresponding to the word.")
],
style=dict(marginTop=".4em", marginBottom="0")),
html.
P("For each genre, we display the words with the largest contributions below.",
style=dict(marginTop=".4em")),
html.Figure(id="interpretation"),
dcc.Interval(id="interval", interval=1000)
],
style=dict(margin="auto", marginTop="1em", width="90%"))
import dash_html_components as html
from funcoes_de_apoio import *
import plotly.graph_objs as go
help_gr_evolução_mensal = html.Div([
"O gráfico mostra a evolução mensal do número de atendimentos no alvo escolhido, ",
"prestados a residentes do município escolhido. ",
"É também mostrada a participação do estabelecimento escolhido nesse atendimento. ",
html.Br(),
"A linha ", html.Em("Taxa da capital x população SUS de ..."),
" é construída multiplicando-se a taxa de atendimentos por habitante-SUS da ",
"capital pela população SUS do município escolhido. ",
"Em outras palavras, essa linha corresponde ao número esperado de atendimentos ",
"ao município escolhido segundo a taxa da capital. ",
"As linhas correspondentes à taxas da UF e do Brasil têm interpretação análoga.",
html.Br(),
"A linha ", html.Em("Limiar log-normal "),
"se refere ao número a partir do qual consideramos ter havido atendimentos em excesso. ",
"Você pode ignorar essa linha, mas se tiver interesse, veja a explicação na aba ",
html.Em("SUSano"),
", seção ",
html.Em("Metodologia"),
".",
html.Ul([html.Li(["Experimente clicar sobre as legendas..."]),
html.Li(["Experimente também os ícones no canto superior direito, que dão acesso a diversas funcionalidades interessantes."])])
])
texto_contato = html.Div([
"Por favor, envie críticas, sugestões e erros que eventualmente perceber para",
html.Br(),
html.A(
"*****@*****.**",
href="mailto:[email protected]",
)
])
texto_metodologia = html.Div([
"Nossa metodologia é muito simples, consistindo em: ",
html.Ul([
html.Li([
"contabilizar os registros nas bases SIA e SIH "
"segundo ",
html.Em("alvos de mineração "),
]),
html.Li("utilizar métodos estatísticos para classificar as taxas de "
"atendimentos por habitante-SUS de cada município como "
"excessivas ou não"),
html.Li("atribuir os atendimentos considerados excessivos aos "
"prestadores que atenderam ao município.")
]),
"Nesta implantação, um alvo de mineração corresponde a uma "
"Forma de Organização, o terceiro nível hierárquico da ",
html.A(
"Tabela do SUS",
href="http://sigtap.datasus.gov.br/tabela-unificada/app/sec/inicio.jsp",
),
html.
P("Para a classificação de atendimentos como excessivos nós partimos da constatação de que, "
html.Br(),
'As entradas estão ordenadas pela coluna "ESCORE EXCESSO", que é o produto '
'do número de atendimentos que nosso tratamento estatístico considerou excessivos, '
'pelo valor médio do atendimento. '
'Para mais detalhes, '
'veja a seção Metodologia na aba SUSano.',
html.Br(),
'Você pode filtrar os registros da tabela por valores em cada coluna. Por exemplo, se você quiser selecionar',
html.Ul([
html.
Li('Apenas registros de estabelecimentos na Bahia, digite "ba" (com ou sem as aspas) '
'na linha de filtro da coluna UF do estabelecimento, e aperte enter'
),
html.Li([
'Registros com alvos do subgrupo 0406/Cirurgia do Aparelho Circulatório, digite "0406" (',
html.Em('com '),
'as aspas) na linha de filtro da coluna de código do alvo '
'(este filtro irá incluir alvos como 030406 Quimioterapia Curativa, que contêm '
'"0406" em seu código)'
]),
html.
Li('Apenas registros do estabelecimento de CNES 1234567, digite "1234567" (com as aspas) na linha de filtro da coluna CNES do estabelecimento'
)
]),
'Você deve usar aspas sempre que sua chave de filtragem for composta somente por algarismos'
])
tabela_EMA = dash_table.DataTable(
id='tabela-EMA',
# data=df_EMA.to_dict('records'),
columns=[{
def display_value(value):
ds = get_collection_metadata(value)
bases = get_history_values(value, "basis")
try:
bases.remove({"label": "None", "value": "None"})
except:
pass
try:
tmp = ds.data.metadata["citations"][0]["acs_citation"]
tmp = tmp.replace("&", "&")
authors, second = tmp.split("<em>")
emph, remaining = second.split("</em>")
bold, remaining = remaining.replace("<b>", "").split("</b>")
italics, remaining = remaining.replace("<i>", "").split("</i>")
doi = ds.data.metadata["citations"][0]["doi"]
citation = html.P([
html.H5("Citation:"),
html.P([
authors,
html.Em(emph),
html.B(bold),
html.I(italics),
remaining,
]),
html.P([
html.B("DOI: "),
html.A(doi,
href=f"https://doi.org/{doi}",
target="_blank"),
]),
])
# citation = citation.replace("</em>", "*").replace(
# "<em>", "*"
# ) # Italics 1
# citation = citation.replace("</i>", "*").replace(
# "<i>", "*"
# ) # Italics 2
# citation = citation.replace("</b>", "**").replace("<b>", "**") # Bold
# citation = citation.replace(", ***", "*, **").replace(
# "***, ", "**, *"
# ) # HTML vs Markdown corrections
except Exception as exc:
logger.error(str(exc))
citation = html.P([
html.H5("Citation:"),
html.I("No information available.")
])
# dedent(
# f"""
# ## Citation:
# *No information available.*
# """
# )
mqcas_help = html.P([
"We are still filling in data and expanding these Webapps. If you have features suggestions or bug reports please file them ",
html.A(
"here",
href=
"https://github.com/MolSSI/QCArchiveWebapps/issues/new/choose",
target="_blank",
),
" or if you wish to expand the datasets, methods, or bases please open an issue ",
html.A(
"here",
href="https://github.com/MolSSI/MQCAS/issues/new/choose",
target="_blank",
),
".",
])
dataset_info = [
dbc.ListGroupItem(x) for x in [citation, mqcas_help]
]
save_access(
page="reaction_datasets",
access_type="dataset_query",
dataset_name=value,
)
mol_index = [{"label": x, "value": x} for x in ds.get_index()]
return (
get_history_values(value, "method"),
bases,
f"{ds.data.name}: {ds.data.tagline}",
mol_index,
mol_index[0]["value"],
dataset_info,
)
],
className="nav navbar-nav navbar-right")
],
className="collapse navbar-collapse",
id="myNavbar")
],
className="container")
],
className="navbar navbar-default navbar-fixed-top")
## team
team = html.Div([
html.Br(),
html.H2('Our Team'),
html.Br(),
html.P(html.Em('We love image processing and would explore further!')),
html.Br(),
html.Div([
html.Div([
html.Div([
html.Img(src=app.get_asset_url('hl.jpg'),
className="img-circle person"),
html.P(html.B('Hongyu Li')),
html.P('*****@*****.**', style={'font-size': '15px'})
],
className="thumbnail name_board")
],
className='col-sm-3'),
html.Div([
html.Div([
html.Img(src=app.get_asset_url('ph.jpg'),
html.Div(
className="jumbotron",
children=[
html.Div([
html.Strong(
"The Development and Access to Information (DA2i) dashboards"
),
html.Span(
" explore key indicators related to meaningful access and use of information in the context of the "
),
html.
A(href=
"https://sustainabledevelopment.un.org/sdgs",
target="_blank",
children="UN 2030 Agenda."),
html.Em(' Select a country'),
html.Span(
" from the dropdown menu to explore its progress in three critical areas: Connectivity, Freedom and Gender Equity."
),
html.Br(),
html.Br(),
html.Span(
"Hover over charts to reveal a menu for interactions such as download or zoom in the top right of the chart."
),
html.Br(),
html.Br(),
html.Span("Visit the "),
html.A(
children="DA2i website",
target="_blank",
href="https://da2i.ifla.org/"),
from __future__ import annotations
import dash_core_components as dcc
import dash_html_components as html
from src.components import navbar
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from dash import Dash
body = html.Div([
html.H3("Compliance: The Basics"),
html.H4("Compliance dashboard generator"),
html.Br(),
html.Span(dcc.Link("Create a new report", href="/new"), id="entry-point"),
html.Br(),
html.Em([
"If you have any questions, please ",
html.A("contact the developer", href="https://forms.gle/5iiLrRdMh1skJfeL9", target="_blank"),
", Adam Turner"])
], className="page-container static-container vertical-center home")
def Homepage(app: Dash) -> html.Div:
return html.Div([
navbar.Navbar(app),
body
], className="page")
default_study_data = pd.read_csv('study.csv')
app.layout = html.Div(
className='',
children=[
html.Div(className='study-browser-banner',
children='Animal Study Browser'),
html.Div(
className='container',
children=[
html.Div(className='row',
children=[
html.Div(className='six columns',
children=[
html.Em("Test Article:"),
dcc.Dropdown(id='study-dropdown', )
]),
html.Div(className='six columns', children=[]),
]),
html.Div(className='row',
children=[
html.Div(className='ten columns',
children=[dcc.Graph(id='plot')]),
html.Div(className='two columns',
children=[
dcc.RadioItems(id='chart-type',
options=[{
'label':
'Box Plot',
'value':
def _get_article(app):
sections = [
html.Div(html.Div([
html.H3("Одна ошибка – (не) страшно!"),
html.P([
"В задачах, где используется хорошо изученная модель или последствия ошибки невелики,"
" объяснение того или иного предсказания действительно может показаться излишним."
" Однако, есть задачи, в которых цена – человеческая жизнь или крупная сумма денежных средств."
" К примеру, ",
html.A("определение курса лечения больного раком",
href="https://www.theverge.com/2018/7/26/17619382/ibms-watson-cancer-ai-healthcare-science",
target="_blank"),
" или ",
html.A("торги на бирже",
href="https://futurism.com/investing-lawsuit-ai-trades-cost-millions",
target="_blank"),
"."
" В таких случаях становится важным понимать, почему модель приняла конкретное решение."
" Иногда это может выявить нерассмотренные краевые случаи "
" (например, если беспилотный автомобиль определяет велосипед по двум колесам,"
" то что же тогда будет с унициклом?)"
" или же факт ",
html.A("половой дискриминации",
href="https://www.reuters.com/article/us-amazon-com-jobs-automation-insight/amazon-scraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUSKCN1MK08G",
target="_blank"),
" при приёме на работу.",
" Но при помощи чего можно ",
html.Em("понять"),
" модель?",
]),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Интерпретируемость моделей"),
html.P([
"Что же это такое? "
" Строгого математического определения нет, "
" но многие считают, что это, говоря простым языком, степень того, насколько человек может понять"
" поведение модели и её логику при принятии того или иного решения."
" Чем выше интерпретируемость модели, тем проще нам, людям, осознавать, как модель пришла к ответу."
]),
html.P([
" Помимо этого, человек – существо любознательное. "
" Нам хочется понимать, как устроен мир и как он работает. "
" Когда машинное обучение применяется в исследованиях и дает хорошие результаты,"
" всё самое интересное остается внутри \"чёрной коробки\"."
" Интерпретируемость моделей позволяет осознать, "
" что именно послужило причиной того или иного предсказания.",
]),
html.P([
" Глобально про интерпретируемость моделей можно рассуждать при помощи разных подходов,"
" мы же выделим две основных группы и обсудим их."
]),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Интерпретация, основанная на особенностях модели"),
html.P(
"Самый простой способ добиться того, чтобы модель можно было понять,"
" –использовать, как бы парадоксально это ни звучало, понятные модели."
" Наиболее известные интерпретируемые модели – это линейная и логистическая регрессии,"
" решающие деревья и решающие правила."
),
html.P(
"Оценить вклад признака `f` у объекта `x` при использовании линейной регрессии"
" можно, посмотрев на вес признака, "
" а оценить его вклад – при помощи произведения веса на само значение."
),
html.P(
" На графиках ниже изображены зависимости между данными абитуриентов,"
" подавших заявки в зарубежные университеты."
" Видно, что линейная регрессия выделила наиболее важным признаком CGPA, "
" что соответствует действительности – ведь у этого параметра наибольшая корреляция"
" с целевой переменной (в данном случае – вероятностью поступления)."
),
html.Div([
html.Img(src=app.get_asset_url("linre-weights.png"), className="linre-image"),
html.Img(src=app.get_asset_url("linre-corr.png"), className="linre-image"),
], className="linre-container"),
html.P(
" Тут могут возникать проблемы: если два признака коррелируют,"
" то первый может забрать себе всю славу и большой вес,"
" а второй останется ни с чем или с противоположным знаком."
),
html.P([
"Неглубокие решающие деревья и небольшие решающие правила очень хорошо воспринимаются людьми "
"– они чем-то похожи на то, как думает человек, и потому понятны сами по себе и хорошо интерпретируемы"
" (подробнее можно почитать ",
html.A("тут", href="https://christophm.github.io/interpretable-ml-book/simple.html",
target="_blank"),
").",
]),
html.P(
"Основным плюсом подхода, основанного на особенностях модели, является то,"
" что самой модели и её архитектуры уже достаточно."
" Нет необходимости строить гипотезы о её работе и при этом"
" в некоторых ситуациях простых моделей оказывается вполне достаточно."
),
html.P(
"Главный же минус виден невооружённым взглядом – данный подход зафиксирован на одной конкретной модели."
" Если нужно скорректировать модель, тонеобходимо изменить подход к интерпретируемости."
" При этом на многих реальных данных линейная регрессия или решающее дерево"
" не смогут сделать ничего толкового."
" Иногда необходимо воспользоваться бустингом или нейронными сетями,"
" но при этом хочется хотя бы примерно понимать,"
" как модели удалось принять правильное решение."
" С такими желаниями приходится обращаться к подходам из следующей группы.",
),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Интерпретация, не зависящая от модели"),
html.P(
"Рассмотрим несколько подходов,"
" которые позволяют объяснять решение сложной модели для конкретного объекта."
" Главное предположение, в рамках которого применяются эти подходы, состоит в том, "
" что сами признаки должны быть интрепретируемы."
" Например, эмбединг товара или пиксель картинки вряд ли скажут что-либо человеку."
" Поэтому вне зависимости от того, насколько сложные признаки использует основная модель,"
" объясняющая компонента должна работать на чем-то упрощенном."
" Для текстов обычно рассматривают мешок слов с ограничением на количество слов,"
" а для картинок группы – похожих пикселей (суперпиксели)."
)
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("LIME"),
html.P([
"Для начала, рассмотрим метод ",
html.Strong("L"),
"ocal ",
html.Strong("I"),
"nterpretable ",
html.Strong("M"),
"odel-agnostic ",
html.Strong("E"),
"xplanations."
" Интуитивно, объяснением для данного подхода может"
" послужить локальная линейная аппроксимация поведения модели."
" Общая идея состоит в том, что рядом с интересующим объектом генерируется группа соседей,"
" после чего исходная модель совершает для них предсказания."
" Затем обучается простая, сама по себе хорошо интерпретируемая суррогатная модель таким образом,"
" чтобы разметка для соседей исходного объекта была правильной."
" После чего для интерпретации исследуется суррогатная модель."
]),
html.Details([
html.Summary("Подробности, алгоритмы и формулы"),
" Зачастую, для объекта с признаковым объяснением `x`"
" его интерпретируемое представление обозначается за `\overline{x}`."
" Также, обозначим сложную исходная модель за `f`,"
" а результатом должна быть объясняющая модель `g`."
" Алгоритм действия следующий:",
html.Ul([
html.Li(
"Перевести интересующее слово в его интерпретируемое представление `\overline{x}`."
),
html.Li(
"Сгенерировать множество интерпретируемых представлений объектов `Z`,"
" близких к `\overline{x}`."
" В случае с текстами и мешком из `k` слов обычно отбрасывают часть слов из предложения."
" Например, для предложения \"Я хочу спать\" близкими будут \" \", \"Я\", \"хочу\","
" \"спать\", \"Я хочу\", \"Я спать\", \"хочу спать\" и \"Я хочу спать\"."
),
html.Li(
"Для каждого `\overline{z} \in Z` восстановить полное описание `z`, после чего"
" узнать `f(z)` и расстояние от `\overline{z}` до `\overline{x}`."
" Измерить расстояние можно разными способами (дальше мы обсудим, почему это плохо),"
" а пока ограничимся каким-нибудь одним."
" Для вышеописанного мешка слов это может быть"
" `\\pi_{\overline{x}}(\overline{z}) = 1 - `доля удаленных слов из `\overline{z}`."
" Точка отсчета в этой метрике расстояния всегда `x`."
),
html.Li(
"Выбрать лучшую `g` из большого класса интерпретируемых моделей,"
" решив задачу оптимизации и поддерживая `g` достаточно простой "
" при помощи штрафа за сложность `\Omega(g)`:"
"$$"
"\operatorname*{arg min}\limits_{g \in G} \sum\limits_{\overline{z}_i \in Z}"
"\\pi_{\overline{x}}(\overline{z}) (f(z) - g(\overline{z}))^2 + \Omega(g) "
"$$"
"Этот функционал сурово штрафует `g` за ошибки в объектах, близких к интересующему,"
" а поэтому локально `g` должна получаться похожей на исходную модель `f`."
" В данном примере используется среднеквадратичная ошибка,"
" но можно использовать любую другую, "
" выбор штрафа за сложность контролировать также несложно."
)
]),
html.P([
" А теперь попробуем реализовать LIME своими руками. Необходимые ингридиенты: "
" Python, scikit-learn, упорство ",
html.Del("и немного текилы"),
". Действовать будем аналогично алгоритму, описанному выше."
]),
html.Img(src=app.get_asset_url("self-lime-1.png"), className="self-lime-1"),
html.P(
"Желающих поэкспериментировать ещё ожидает целый раздел в эпилоге."
),
]),
html.P([
"Одна из проблем данного метода состоит в большой свободе:"
" выбор функции близости и функционала ошибки довольно сильно влияет на результат."
" При этом есть примеры ситуаций, когда разные функции приводят к результатам максимально далеким"
" – это явно не хорошо для интерпретируемости."
" В разделе про SHAP мы покажем, как с этим бороться." # TODO: link
]),
html.P(
"Давайте посмотрим, как LIME работает на деле. Ему был предложен набор данных, "
" из предложений на английском языке, которые размечены на 6 эмоциональных классов. Задача –"
" распознать эмоциональное состояние человека."
),
html.Img(src=app.get_asset_url("emo-lime.png"), className="emo-image"),
html.P(
"Синим цветом выделены признаки (в нашем случае слова) наиболее характерные для класса \"sadness\"."
" Видно, что LIME'у удаётся интерпретировать результаты модели"
" почти как и человеку, читающему предложение."
),
html.P(
"Ещё один поучительный пример: на данных, "
" представленных в виде писем и новостей по 20 различным тематикам,"
" модель `\\text{RandomForestClassifier}` показывает хорошие результаты, "
" достигая значение метрики `\\text{F1} = 0.925`."
" Посмотрим, что об этом думает LIME."
),
html.Img(src=app.get_asset_url("christ-lime.png"), className="christ-lime"),
html.P(
"Из графика становится видно, что слово \"writes\" чаше встречалось в тематике про атеизм,"
" однако прямого взаимотношения нет, это лишь совпадение. То есть, LIME смог выявить проблему в данных,"
" своего рода \"утечку целевой переменной\"."
),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Shapley Values"),
html.P(
"Shapley Values – невероятно красивый и интересный подход сам по себе,"
" потому что основан на результате из теории игр."
" Исходная постановка задачи звучит так:"
" есть игроки, которые могут объединяться и работать вместе."
" Зарплату получают одну на всех, но она завиcит от качества работы."
" Как честно разделить деньги между теми, кто поработал?"
),
html.P(
"Будем считать, что значения признаков конкретного объекта – это игроки, "
" они вносят вклад в предсказание. "
" Обычно говорят, что они вносят вклад в сдвиг ответа модели от среднего ответа. "
" Заплатим всем значениям признаков зарплату в размере разницы между предсказанием на данном объекте"
" и средним предсказанием. Как признакам честно разделить между собой деньги?"
),
html.P(
"По теореме Шепли оказывается, что существует единственное распределение,"
" удовлетворяющие четырем разумным свойствам, которые мы обсудим чуть позже."
" Признак или игрок `i` должен получать среднее "
" по всем возможным подмножествам игроков (коалициям) значение вносимой им пользы:"
"$$"
"\phi_i(v) = \sum\limits_{S \subset N \setminus \{ i\}} \\frac{|S|! \, (n - |S| - 1)!}{n!}"
"\, (v(S \\cup \{ i \}) - v(S))"
"$$"
"Здесь `N` – множество всех игроков,"
" `S` пробегает его подмножества без `i`-го игрока,"
" `v` показывает сколько заплатят за работу конкретной коалиции."
" Самый важный множитель тут последний,"
" он как раз показывает вносимую пользу,"
" сложное начало с факториалами нужно для правильного учета размера коалиций при усреднении."
),
html.Details([
html.Summary("Честная постановка задачи и подробности про теорему"),
html.P(
"В игре есть `n` игроков, их множество обозначается за `N`."
" Любое (даже пустое) подмножество игроков называется коалицией."
" Функция выплат `v` для каждой коалиции показывает, сколько бы ей заплатили,"
" если бы игроки этой коалиции работали вместе."
" Итак, `v : 2^{\mathbb{N}} \\to \mathbb{R}`."
" Говорят, что пустая коалиция всегда получает 0."
" В случае моделей это может быть разумно – "
" совсем не имея признаков, мы скорее всего выдадим"
" средний результат по всем объектам из обучающей выборки."
),
html.P(
"Рассмотрим игрушечный пример."
" Есть два электрика: `N = \{ 1, 2 \}`."
" Первый – молодой и может залезть на верх лестницы и вкрутить лампочку,"
" второй – пожилой и уже не может подняться по лестнице, "
" но со старостью приходит мудрость, поэтому только он знает, где лежат новые лампочки."
" Поэтому электрики получат деньги, только если поработают вместе:"
"$$"
"v(\{ \emptyset \}) = 0, \quad v(\{1 \}) = 0, \quad v(\{ 2 \}) = 0, \quad v(\{ 1, 2 \}) = 100"
"$$"
"Как им честно поделить эти 100 рублей?"
" Настоящее определение честности мы дадим немножко позже, "
" но пока интуитивно хочется сказать, что каждому нужно дать по 50."
),
html.P(
"Немного изменим условие задачи:"
" на самом деле, молодой электрик может сходить в магазин и купить лампочку за 60,"
" то есть в одиночку может заработать 40."
" А пожилой электрик может сквозь боль залезть по лестнице,"
" вкрутить лампочку, после чего придётся сходить в аптеку за мазью от растяжения спины."
" Мазь стоит 90, откуда получаем следующую функцию выплат:"
"$$"
"v(\{ \emptyset \}) = 0, \quad v(\{1 \}) = 40, \quad v(\{ 2 \}) = 10, \quad v(\{ 1, 2 \}) = 100"
"$$"
"Понятно, что для устойчивости (никто не хочет выйти из коалиции при прочих равных условиях)"
" достаточно дать молодому немножко больше 40, а пожилому – немножко больше 10. "
" Но как тут разделить честно?"
),
html.P(
"Говорят, что честная функция дележа должна обладать следующими свойствами:"
),
html.Ol([
html.Li(
"Симметричностью по игрокам. Если для каждой коалиции `S`, не содержащей игроков `i` и `j`"
" выполняется `v(S \cup \{ i \} ) = v(S \cup \{ j \} )`, то `i` и `j` должны получить "
" равную плату после дележа. Это требование очень логично для интерпретируемости:"
" мы хотим сравнивать вклады признаков между собой. Будет плохо, если одинаково работающие"
" признаки будут получать разное значение."
),
html.Li(
"Эффективностью."
" При дележе будут розданы все деньги и всем хватит. "
" Мы хотим объяснить именно весь сдвиг от среднего значения."
),
html.Li(
"Свойством болвана. "
" Если какой-то игрок не привносит ничего ни в какой коалиции,"
" он должен получить 0. Действительно, если какое-то значение признака"
" никогда не меняет предсказания модели, им вряд ли можно хоть что-то объяснить."
),
html.Li(
"Линейностью по функциям выплат."
" Пусть для одного множества игроков есть две функции выплат `v` и `w`."
" Мы хотим, чтобы сумма доставшихся игроку после отдельных дележей денег"
" для двух функций совпадала с полученным им при рассмотрении игры с функцией `v + w`."
" Это свойство может пригодится для интерпретируемости ансамблей моделей,"
" когда результат – усреднение результатов отдельных частей."
),
]),
html.P(
"Утверждается, что функция Шепли – единственная удовлетворяющая "
" всем этим четырем требованиям функция. Например, для электриков получается,"
" что молодой должен получить `(40 + 90) / 2 = 65`, а пожилой `(10 + 60) / 2 = 35`."
),
]),
html.P(
"Разберем подробнее то, как результат Шепли можно применить для интерпретируемости. "
" Самый наивный подход состоит в том, чтобы честно подсчитать всё нужное в формуле."
" Для моделей с табличными данными это будет означать,"
" что для каждого подмножества признаков надо заново обучить модель,"
" чтобы узнать зарплату v для него."
),
html.P(
" Конечно, это слишком долго, и так не делают."
" Обычно, вместо полного удаления признака его заменяют на значение этого же признака"
" у произвольно выбранного объекта из выборки."
" Для картинок, к примеру, можно заменять суперпиксели на серый цвет, "
" с другой стороны, для текстов такая проблема иногда даже не возникает,"
" так как модели не завязаны на определенное количество слов."
" Но даже так, с одной моделью перебор всех возможных коалиций"
" потребует экспоненциального от числа признаков времени."
" Поэтому используют различные приближения (например, метод Монте-Карло)."
),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Kernel SHAP"),
html.P([
"Наконец, рассмотрим Kernel SHAP (SHapley Additive exPlanations), своего рода"
" объединение Lime и Shapley Values."
" Как обсуждалось в части про Lime, результат сильно зависит от выбора функции расстояния"
" и функционала ошибки, еще и штраф за сложность модели там выбирался произвольно."
" Оказывается, что если обозначить за `|\overline{z}|` число ненулевых координат вектора, "
" за `M` – число признаков в интерпретируемом представлении и положить"
"$$"
"\Omega(g) = 0, \quad \pi_{\overline{x}}(\overline{z}) = "
"\\frac{M - 1}{\\binom{M}{|\overline{z}|} \, |\overline{z}| \, (M - |\overline{z}|)}, \quad"
" L(f, g, \pi_{x'}) = \sum\limits_{z' \in Z} "
"\pi_{\overline{x}}(\overline{z}) [f(z) - g(\overline{z})]^2,"
"$$"
"то ответ модели Lime является хорошим приближением Shapley Values."
" Доказательство этого факта можно найти в ",
html.A("оригинальной статье",
href="https://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf",
target="_blank"),
"."
]),
html.P(
"Может показаться, что SHAP замечательный, и это правда так – сама идея раздавать признакам"
" зарплату невероятная, но и у этой модели есть свои минусы. "
" Например, Kernel SHAP медленный, а все существующие ускорения приводят "
" к потерям важных свойств описанных выше.",
),
html.P([
"Рассмотрим SHAP в работе: данные аналогичны тем, на которых мы разбирали LIME, – предложения,"
" для которых нужно предсказать эмоциональную окраску. Для конкретного примера ",
"\"im feeling quite sad and sorry for myself but ill snap out of it soon\"",
" алгоритм даёт следующие результаты:",
]),
html.Img(src=app.get_asset_url("emo-shap.png"), className="emo-shap"),
html.P(
"Напоминание: предсказание представимо в виде \"sadness\" или не–\"sadness\" (так же, как и у LIME)."
" Опять-таки, видно, что SHAP'у удаётся уловить главные слова так же, как это бы сделал человек."
),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Лимонад vs. Шнапс"),
html.P(
"Настало время сравнить две модели в одинаковых условиях."
),
html.H5("Недвижимость"),
html.P(
"Первый набор данных – стоимость квартир в Москве, всё это представлено в виде таблицы."
),
html.Img(src=app.get_asset_url("flats-1-shap.png"), className="flats-1-shap"),
html.P(
"Из графика видно, что близость к метро (metrdist и walk) и расстояние до центра (dist) повышают цену,"
" в то время как маленькая жилая площадь (totsp = 60) понижает её."
),
html.Img(src=app.get_asset_url("flats-1-lime.png"), className="flats-1-lime"),
html.P(
"По большому счёту, LIME уловил те же тенденции и справился с поставленной задачей. Ничья!"
),
html.H5("Образование"),
html.P(
"Вернёмся к нашим абитуриентам."
),
html.Img(src=app.get_asset_url("admission-shap.png"), className="admission-shap"),
html.P(
"Хорошие баллы за выпускные экзамены и TOEFL повышают шансы старшеклассника на поступление,"
" а не самый высокий средний балл наоборот понижает."
),
html.Img(src=app.get_asset_url("admission-lime.png"), className="admission-lime"),
html.P(
"В данном примере LIME пришёл к такому же выводу. Снова ничья! "
"Однако, стоит упомянуть, что SHAP работает немногим дольше LIME'a."
),
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Что мы узнали и поняли"),
html.P(
"Своего рода rule of thumb звучит так: если нужны максимально подробные объяснения"
" и есть время, то стоит использовать SHAP; если же ждать некогда,"
" то можно применять LIME, но делать это стоит осторожно (подробнее об этом в эпилоге)."
),
html.P(
"На большинстве реальных данных результаты SHAP и LIME очень похожи, если даже не одинаковы."
" Однако, исходя из теории, SHAP должен выдавать объяснения лучше."
" К тому же его необходимо настраивать значительно меньше, так как у него меньше степеней "
" свобод по сравнению с LIME."
),
html.P(
"Возможно, когда-нибудь в ближайшем будущем, машинное обучение станет автоматизированным, "
" а вместе с ним и извлечение интерпретации моделей, но до тех пор мы должны "
" с осторожностью и внимательностью относиться к предсказаниям искусственного интеллекта"
" в жизненно важных областях."
)
], className="content-wrapper"), className="content"),
html.Div(html.Div([
html.H3("Эпилог. Фрэш для сильных духом"),
html.P([
"В разделе про внутреннее устройство LIME было подробное описание самого алгоритма."
"Теперь попробуем менять две вещи: "
]),
html.Ul([
html.Li("Функцию расстояния (евклидова, постоянная, манхэттонская, Чебышева),"),
html.Li("Функцию (сейчас будет сложно), переводящую функцию расстояния в функцию близости."),
]),
html.P([
"Мы хотим больше наказывать за ошибки в объектах,"
" совсем близких к нашему, а значит, они должны получать большие веса."
" Проверим два варианта: `1 / f(x)` и `\exp(-f(x))`."
]),
html.Img(src=app.get_asset_url("self-lime-3.png"), className="self-lime-3"),
html.P(
"Можно заметить, что при изменении функции расстояния и функции перевода всё меняется."
" Это показывает слабую сторону Lime. Конечно, никто не знает заранее, какую функцию лучше выбрать и"
" в какой ситуации её применить, а значит, можно получать разные интерпретации."
" Внутри библиотеки выбраны определенные параметры по умолчанию, но никаких гарантий нет."
),
html.P(
" В примере выше интерпретации хоть как-то близки "
" (в большинстве случаев они были бы вполне приемлемыми), "
" но при переходе в большие размерности проблемы могут накапливаться ещё сильнее."
" Поэтому LIME надо применять с осторожностью и головой на плечах."
),
html.P(
"Теперь будем не генерировать новых соседей, а рассматривать всю выборку"
" в качестве соседей изучаемой точки. Удалённые точки получат совсем маленький вес,"
" а близкие – большой, из-за чего будут влиять на ситуацию."
" Проверим, как это сработает на следующем примере."
),
html.Img(src=app.get_asset_url("self-lime-4.png"), className="self-lime-4"),
html.P(
"Теперь попробуем сгенерировать данные посложнее."
),
html.Img(src=app.get_asset_url("self-lime-5.png"), className="self-lime-5"),
html.P(
"Сравним с LIME'ом."
),
html.Img(src=app.get_asset_url("self-lime-6.png"), className="self-lime-6"),
html.P(
"Пожалуй, у LIME'а получилось лучше, чем у новой идеи."
" Возможно, поможет изменить функцию перехода от расстояния к близости,"
" но тогда это будет слишком похоже на сам LIME."
" В целом, было ожидаемо, что для локального обоснования не надо смотреть на весь датасет,"
" но попробовать хотелось :)"
)
], className="content-wrapper"), className="content"),
]
return sections
# APP COMPONENTS
# ==========
header = dbc.Jumbotron(
[
html.H1("Justices", className="display-2"),
html.P("An Analysis of Supreme Court Case Transcripts Since 2005")
],
className='my-div text-center',
)
tab1_content = ([
html.H2(prose_df.loc["modal_use", "title"]),
html.P(prose_df.loc["modal_use", "prose_1"]),
dcc.Graph(figure=modal_table),
html.P([
prose_df.loc["modal_use", "prose_2a"],
html.Em(prose_df.loc["modal_use", "prose_2_em"]),
prose_df.loc["modal_use", "prose_2_b"]
]),
html.P([
"\"",
html.Strong(prose_df.loc["modal_use", "example_1_strong"]),
prose_df.loc["modal_use", "example_1_b"],
html.P(prose_df.loc["modal_use", "example_1_c"]),
prose_df.loc["modal_use", "example_2_a"],
html.Strong(prose_df.loc["modal_use", "example_2_strong"]),
prose_df.loc["modal_use", "example_2_b"],
]),
html.P(prose_df.loc["modal_use", "prose_3"]),
dcc.Graph(figure=modal_bar),
html.P(prose_df.loc["modal_use", "prose_4"]),
])
def main(indicators_df_path, senti_df_path):
"""
creates the Dash app frontend visualization interface to show correlation coefficients between monthly/daily news sentiment and economic indicators.
Arguments:
- indicators_df_path(str): The csv file that contains all the indicators values.
- senti_df_path(str): The csv file containing aggregated sentiment dataframe that includes both annotated and predicted data for under each indicator and each source.
"""
indicators_df = pd.read_csv(indicators_df_path, parse_dates=['date'])
#read in sentiment data
combined_senti_df = pd.read_csv(senti_df_path,
parse_dates=['publishedAt'],
index_col='publishedAt')
## main function of Dash app frontend
indicators = [
'GDP', 'mortgage rates', 'interest rates', 'employment',
'housing prices', 'TSX'
]
sources = ['All sources', 'Source-weighted Average', 'Bloomberg', 'CBC']
default_indicator = 'GDP'
default_source = 'All sources'
senti_colname_dict = {
'GDP': 'gdp',
'employment': 'employment',
'housing prices': 'housing',
'interest rates': 'interest',
'mortgage rates': 'mortgage',
'TSX': 'stock'
}
## current weights for each source are just placeholder values
## can change them to other weights according to your judgement
## can add more news sources and their associated weights, all weights should sum to 1
source_wgt_dict = {'Bloomberg': 0.7, 'CBC': 0.3}
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.layout = html.Div([
html.H3("Canadian News Sentiment Swings As Economy Evolves"),
html.Div([
html.Div([
html.P("Pick an economic indicator and a news source: "),
dcc.Dropdown(
id='indicator-name',
options=[{
'label': i[0].capitalize() + i[1:],
'value': i
} for i in indicators],
value=default_indicator, # set a default value
optionHeight=30),
dcc.Dropdown(
id='source-name',
options=[{
'label': i,
'value': i
} for i in sources],
value=default_source, # set a default value
optionHeight=30),
html.Br(),
html.Div([
html.Label("Pick a chart type: ",
style={'display': 'inline-block'}),
dcc.RadioItems(id='chart-type',
options=[{
'label': 'Monthly average',
'value': 'line'
}, {
'label': 'Daily datapoints',
'value': 'scatter'
}],
value='line',
labelStyle={'display': 'inline-block'})
])
]),
html.Div([
html.Em(id='correlation-coef'),
html.Label(' in the period'),
dcc.DatePickerRange(
id='date-picker-range',
min_date_allowed=dt(2010, 1, 1),
#max_date_allowed=dt(2017, 9, 19),
initial_visible_month=dt(2020, 6, 1),
start_date=dt(2019, 1, 1).date(
), #set default start_date to the earliest date of available data
end_date=dt(2020, 6, 1).date(
) #set default end_date to the latest date of available data
),
]),
]), #style={'columnCount': 2}
dcc.Graph(id='indicator-senti-graph'), #figure=test_fig
html.P("Notes: "),
html.
P(" * Daily datapoints of news article sentiment is a combination of customized sentiment analyzer model predictions plus hand-made golden annotations."
),
html.
P(" * On Source-weighted Average option -- Current source-weights are: "
+ str(source_wgt_dict)),
html.A('Download News Sentiment Data Subset',
id='download-link',
download="rawdata.csv",
href="",
target="_blank"),
])
@app.callback(Output("correlation-coef", "children"), [
Input("indicator-name", "value"),
Input("source-name", "value"),
Input('date-picker-range', 'start_date'),
Input('date-picker-range', 'end_date')
])
def update_corr(indicator_name, source_name, start_date, end_date):
#reference from documentation: https://dash.plotly.com/dash-core-components/datepickerrange
start_date = dt.strptime(re.split('T| ', start_date)[0], '%Y-%m-%d')
end_date = dt.strptime(re.split('T| ', end_date)[0], '%Y-%m-%d')
try:
corr = get_correlation(combined_senti_df,
indicators_df.set_index('date'),
indicator_name,
source_name,
start_date=start_date,
end_date=end_date)
except:
corr = None
string = str(round(corr, 2)) if corr else "--"
return "Correlation coeficient between " + indicator_name + " and selected source sentiment is: " + string
@app.callback(
[
Output("indicator-senti-graph", "figure"),
Output("download-link", 'href')
], # must be a single Output item when returns only one value
[
Input("indicator-name", "value"),
Input("source-name", "value"),
Input("chart-type", "value"),
Input('date-picker-range', 'start_date'),
Input('date-picker-range', 'end_date')
])
def update_graph(indicator_name, source_name, chart_type, start_date,
end_date):
indicator_colname = 'value_' + "_".join(
indicator_name.split()) # value_mortgage_rates
indicator_df = indicators_df[['date', indicator_colname
]].dropna().rename(columns={
indicator_colname: "values",
"date": "dates"
})
indicator_label = indic_to_value[indicator_colname]
test_title = indicator_name + ' VS news sentiment ' #(most recent 12 months data)
senti_colname = senti_colname_dict[indicator_name]
#filtering by date range
start_date = dt.strptime(re.split('T| ', start_date)[0], '%Y-%m-%d')
end_date = dt.strptime(re.split('T| ', end_date)[0], '%Y-%m-%d')
comb_senti_df = combined_senti_df.sort_index()
try:
combo_senti_df = comb_senti_df[start_date:end_date]
except:
#for invalid dates, give the full period
combo_senti_df = comb_senti_df
senti_df = combo_senti_df.query(
'indicator == @senti_colname').drop_duplicates('title_desc')
if source_name == 'Source-weighted Average':
#ref: source_dict = {'Bloomberg': [bbg_gdp_avg, 0.5], 'CBC': [cbc_gdp_avg, 0.5]}
source_dict = {}
for src in list(source_wgt_dict.keys()):
source_df_subset = get_monthly_avg_score(
senti_df.query(' source == @src '))
source_dict[src] = [source_df_subset, source_wgt_dict[src]]
monthly_senti_df = monthly_weighted_average(source_dict)
month_senti_df = monthly_senti_df.rename(
columns={'monthly_weighted_ave_sent_score': 'final_sentiment'})
daily_senti_df = daily_weighted_average(
senti_df, source_wgt_dict).rename(
columns={'raw_sentiment_score': 'final_sentiment'})
else:
if source_name != 'All sources':
senti_df = senti_df.query('source ==@source_name ')
monthly_senti_df = get_monthly_avg_score(senti_df)
month_senti_df = monthly_senti_df.rename(
columns={'monthly_avg_sent_score': 'final_sentiment'})
daily_senti_df = senti_df.rename(
columns={'raw_sentiment_score': 'final_sentiment'})
if chart_type == 'line':
chart = plot_combined_graph_new(indicator_df, month_senti_df,
indicator_label, test_title)
else:
chart = plot_combined_graph_scatter(indicator_df, daily_senti_df,
indicator_label, test_title)
#export raw sentiment df with column names including "publishedAt","source", "title_desc", "raw sentiment score", "indicator" and "anotation_type"
csv_string = senti_df.to_csv(encoding='utf-8')
csv_string = "data:text/csv;charset=utf-8,%EF%BB%BF" + urllib.parse.quote(
csv_string)
return chart, csv_string
app.run_server(debug=True)
html.Td("R$ " + f_float(ds.valor_médio_anual_EMA),
style={'textAlign': 'right'})
]))
table_body = [html.Tbody(rows)]
return dbc.Col(
html.Div([dbc.Table(table_header + table_body, size='sm')]),
width={
"size": 8,
"offset": 2
},
)
help_relatório_alvo = html.Div([
"Dados do alvo escolhido.",
html.Em("Excesso"), " é o produto do número de atendimentos que nosso ",
"tratamento estatístico considerou excessivos, pelo valor médio ",
"do atendimento. Para mais detalhes, veja a seção ",
html.Em("Metodologia"), " na aba ",
html.Em("SUSano.")
])
def descrição_estabelecimento(dg, ds):
table_header = [
html.Thead(
html.Tr(
[html.Th(ds.E_em_foco.upper(), style={'textAlign':
'center'})]))
]
className='text-muted',
style={'fontSize': "14px"})
]),
row([
dcc.Input(id='simple-volumes-large-panel-count',
className='border-bottom',
min=0,
value=0,
type='number'),
" Large panels per year ",
html.Span("(300 genes / ~1GB BAM size).",
className='text-muted',
style={'fontSize': "14px"})
]),
row([
html.Em("Files are stored as: "),
dcc.RadioItems(id='file-type-radio',
options=[{
'label': 'BAM',
'value': 'BAM'
}, {
'label': 'CRAM v2',
'value': 'CRAMV2'
}, {
'label': 'CRAM v3',
'value': 'CRAMV3'
}],
value='BAM',
style={"display": "inline"},
labelStyle={
'fontWeight': 'normal',
