def call_html():
import IPython
display(
IPython.core.display.HTML('''
<script src="/static/components/requirejs/require.js"></script>
<script>
requirejs.config({
paths: {
base: '/static/base',
"d3": "https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.8/d3.min",
jquery: '//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min',
},
});
</script>
'''))
def render(self):
from metakernel.display import display
display(self.top_level)
def render(self):
from metakernel.display import display
display(self.top_level)
def _pngDisplay(self):
display(self.getPngImage())
def _jsDisplay(self):
'''Overloaded method to display with metakernel.display'''
display(HTML(self.getJsCode()))
def plot(self):
print("Reading data")
# Vemos cual es la extensión
exten = self.file.split('.')
extension = exten[len(exten) - 1]
# Leemos los archivos .tsv
if extension == 'tsv':
df = pd.read_table(self.file)
df = df.drop(
list(df)[-1], 1
) #Para los archivos .tsv eliminamos la última columna que se suele leer y no tiene nada
# Calculamos los índices para poder hacer los plots
print("Calculate indexes")
par = list(df)
# Añadimos los índices
df[len(par)] = df.index
# Establecemos nombres a las columnas
df.columns = ["Strike", "TC", "SP", "Index"]
# Damos opción para indicar tags diferentes
if self.tags != None:
dfd = self.tags
dfd.append("Indice")
if (len(dfd) == len(list(df))):
df.columns = dfd
else:
raise Exception("Number of tags: " + str(len(dfd) - 1) +
" missmatched column length --> " +
str(len(list(df)) - 1))
# Leemos archivos que acepta read_csv
elif (extension == 'csv' or extension == 'txt'):
df = pd.read_csv(self.file)
name_data_frame = list(df)
if self.normalization == True:
print("Normalizing data")
# Eliminamos temporalmente ultima columna
num = df[list(df)[-1]]
df = df.drop(list(df)[-1], 1)
# Normalizamos los datos
x = df.values # returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
df = pd.DataFrame(x_scaled)
# Volvemos a añadir el dataFrame
df[len(list(df))] = num
df.columns = name_data_frame
print("Calculating best ranges")
# Inicializamos las variables
max_range_values = []
min_range_values = []
final_max_value = 0
final_min_value = 0
#Creamos una lista con los nombres de las columnas
pared = list(df)
for l in range(0, len(pared) - 1):
max1 = max(df[pared[l]])
min1 = min(df[pared[l]])
if l < len(pared) - 3:
max2 = max(df[pared[l + 1]])
min2 = min(df[pared[l + 1]])
max_range_values.append(max(int(max1 * 2), int(max2 * 1.2)))
min_range_values.append(min(min1 - 1, min2 - 1))
if l == len(pared) - 2:
max_range_values.append(max(df[pared[l]] * 1.2))
min_range_values.append(min(df[pared[l]]))
final_max_value = max(max_range_values)
final_min_value = min(min_range_values)
print("Plotting data")
if self.library == 'pyplot':
division = list(df)[-1]
# Limpiamos la figura en caso de que tuviesemos algo
plt.close()
plt.figure()
plt.clf()
# Ofrece la opción de plotear de un solo color
if self.color_unique == True:
fig = parallel_coordinates(df, division, color=('#556270'))
elif self.color_unique == False:
fig = parallel_coordinates(df, division)
# Ofrece la opcion de eliminar la leyenda
if (self.remove_legend == True):
plt.gca().legend_.remove()
# Ofrece la opcion de guardar la gráfica
if self.autosave == True:
plt.savefig(self.save_file_name)
# Mostramos la gráfica
plt.show()
fig = df
elif self.library == 'plotly':
# Vamos a generar unos indices para poder identificar las columnas en forma de ids
levels = df[pared[-1]].unique()
new_column = []
for o in range(0, len(df[pared[-1]])):
for q in range(0, len(levels)):
if df[pared[-1]][o] == levels[q]:
new_column.insert(o, q)
df[len(list(df))] = new_column
df = df.rename(columns={len(list(df)) - 1: "autoIndexes"})
print(len(list(df)))
if len(list(df)) == 8:
data = [
go.Parcoords(
# Añadimos el id y los colores que vamos a usar
line=dict(color=df['autoIndexes'],
colorscale=[[0, '#D7C16B'], [0.5, '#23D8C3'],
[1, '#F3F10F']]),
dimensions=list([
# Vamos a añadiendo las diferentes subplots que se añaden al final
dict(range=[final_min_value, final_max_value],
label=pared[0],
values=df[pared[0]]),
dict(range=[final_min_value, final_max_value],
label=pared[1],
values=df[pared[1]]),
dict(range=[final_min_value, final_max_value],
label=pared[2],
values=df[pared[2]]),
dict(range=[final_min_value, final_max_value],
label=pared[3],
values=df[pared[3]]),
dict(range=[final_min_value, final_max_value],
label=pared[4],
values=df[pared[4]]),
dict(range=[final_min_value, final_max_value],
label=pared[5],
values=df[pared[5]])
]))
]
#Tenemos esto para diferente numero de colimnas
if len(list(df)) == 7:
data = [
go.Parcoords(
line=dict(color=df['autoIndexes'],
colorscale=[[0, '#D7C16B'], [0.5, '#23D8C3'],
[1, '#F3F10F']]),
dimensions=list([
dict(range=[final_min_value, final_max_value],
label=pared[0],
values=df[pared[0]]),
dict(range=[final_min_value, final_max_value],
label=pared[1],
values=df[pared[1]]),
dict(range=[final_min_value, final_max_value],
label=pared[2],
values=df[pared[2]]),
dict(range=[final_min_value, final_max_value],
label=pared[3],
values=df[pared[3]]),
dict(range=[final_min_value, final_max_value],
label=pared[4],
values=df[pared[4]])
]))
]
if len(list(df)) == 6:
data = [
go.Parcoords(
line=dict(color=df['autoIndexes'],
colorscale=[[0, '#D7C16B'], [0.5, '#23D8C3'],
[1, '#F3F10F']]),
dimensions=list([
dict(range=[final_min_value, final_max_value],
label=pared[0],
values=df[pared[0]]),
dict(range=[final_min_value, final_max_value],
label=pared[1],
values=df[pared[1]]),
dict(range=[final_min_value, final_max_value],
label=pared[2],
values=df[pared[2]]),
dict(range=[final_min_value, final_max_value],
label=pared[3],
values=df[pared[3]])
]))
]
if len(list(df)) == 5:
data = [
go.Parcoords(
line=dict(color=df['autoIndexes'],
colorscale=[[0, '#D7C16B'], [0.5, '#23D8C3'],
[1, '#F3F10F']]),
dimensions=list([
dict(range=[final_min_value, final_max_value],
constraintrange=[4, 8],
label=pared[0],
values=df[pared[0]]),
dict(range=[final_min_value, final_max_value],
label=pared[1],
values=df[pared[1]]),
dict(range=[final_min_value, final_max_value],
label=pared[2],
values=df[pared[2]])
]))
]
# Coloreamos el fondo de la figura
layout = go.Layout(plot_bgcolor='#E5E5E5', paper_bgcolor='#E5E5E5')
# Utilizamos la librería offline de plotly para hacer el gráfico
fig = go.Figure(data=data, layout=layout)
if self.autosave == True:
off = offline.plot(fig,
image='png',
output_type='file',
image_filename=self.save_file_name,
filename=self.save_file_name)
if self.autosave == False:
off = offline.iplot(fig)
display(HTML(off))
elif self.library == 'bokeh':
plots = []
nombres = list(df)
count = 0
df.sort_values(nombres[1])
colourname = []
for i in range(0, len(nombres) - 2):
# Generamos la figura
p = figure(x_range=(1, 5),
x_axis_label=nombres[i] + ' ' +
nombres[i + 1],
y_range=(final_min_value, final_max_value),
plot_width=400,
plot_height=400)
xs = []
ys = []
# Coloreamos 25%-25%-25%-25%
for j in range(0, len(df[nombres])):
if i == 0:
if j < len(df[nombres[i]]) / 4:
colourname.append(colors[1])
elif j >= len(df[nombres[i]]) / 4 and j < (
2 * len(df[nombres[i]]) / 4):
colourname.append(colors[2])
elif j >= 2 * len(df[nombres[i]]) / 4 and j < 3 * len(
df[nombres[i]]) / 4:
colourname.append(colors[3])
elif j >= 3 * len(df[nombres[i]]) / 4 and j < 4 * len(
df[nombres[i]]) / 4:
colourname.append(colors[4])
# Añadimos los valores
xs.append([1, 5])
ys.append([df[nombres[i]][j], df[nombres[i + 1]][j]])
count += 1
# Generamos el plot
if self.color_unique == True:
p.multi_line(xs, ys, line_width=4)
else:
p.multi_line(xs, ys, color=colourname, line_width=4)
p.add_tools(PanTool(), WheelZoomTool(), LassoSelectTool())
plots.append(p)
# Añadimos las diferentes gráficas generadas
fig = gridplot([plots], sizing_mode='stretch_both')
if self.autosave == True:
save(fig)
export_png(fig, filename=self.save_file_name)
# Mostramos el total de las gráficas generadas
show(fig)
return fig
