Daniel Molina Profile

Estancia en la Universidad de Surrey

2026-01-27T00:00:00+00:00

Desde este año, estoy realizando una estancia en la Universidad de Surrey</a>. Esta universidad tiene un campus agradable y está ubicada en Guildford</a>, a unos 40-50 minutos de Londres en tren.

He venido aquí para conocer a más gente y empezar una colaboración con Ferrante Neri</a>, un investigador muy productivo</a> con una larga experiencia en Computación Evolutiva que ha sido capaz de adaptar su investigación a Neuroevolución y otros temas interesantes. Actualmente, compartimos una línea de investigación con uno de mis estudiantes de doctorado, Abel, sobre NAS utilizando Computación Evolutiva.

También he estado en contacto con Roman Bauer</a>, que trabaja en simulaciones biológicas mediante agentes, para estudiar y trabajar en enfermedades y medicamentos. Un enfoque muy interesante, y hemos hablado un poco sobre colaboraciones con él.

Curiosamente, obtuve alojamiento en una habitación con cocina compartida en la propia universidad, y en esa cocina conocí a Isaiah, un médico keniano en ingeniería química que busca un puesto de postdoctorado, y él me puso en contacto con más investigadores de ese Departamento, que curiosamente también trabajan con Roman, y es posible que iniciemos una colaboración muy pronto (construyendo una red interesante).

Además de trabajar mucho con mis estudiantes de doctorado y asistir a reuniones, he estado explorando varios lugares interesantes durante los fines de semana, como Farnham, Portsmouth o el Castillo de Windsor.

Publicaciones en Revistas Internacionales

2024-01-14T00:00:00+00:00

Visitando Londrina

2023-11-29T00:00:00+00:00

Entre Noviembre y Diciembre he viajado a Londrina en Brasil. En particular, he visitado la Universidade Estadual de Londrina</a>.

He realizado el viaje acompañando a mi pareja, que tenía comprometido dar un curso en un programa de máster de ahí, mientras que en mi caso he sido invitado por personal del Departamento de Computacao. En mi caso, he participado:

Visitando el Departamento de Computaçao de Londrina</a>, gracias a la invitación de Daniel dos Santos Kaster, que está siendo muy amable conmigo. También he dado una charla en su Dpto sobre mis trabajos y los de mi grupo, y hemos empezado contacto para posibles colaboraciones.</li> </ul>

- Por otro lado, también he dado una charla de divulgación para estudiantes en general:</li> </ul>
 
 Que estuvo muy bien:
 
 Con una presentación muy chula:
 </a>
 Que he puesto libremente disponible en zenodo</a>, que por cierto, es todo un descubrimiento para almacenar contenido de interés como transparencias. También está en mi sección de Charlas</a>.

Listado como uno de los investigadores más influyentes

2023-10-18T00:00:00+00:00

Ha salido mi nombre en la lista de los investigadores más influyentes del mundo, según el ranking de Stanford, que considera aquellos investigadores de todas las áreas que más influencia (citas) reciban:

https://www.granadahoy.com/granada/Universidad-Granada-investigadores-influyentes-Stanford_0_1838516842.html</a>

https://www.ugr.es/universidad/noticias/ugr-record-154-investigadores-mas-influyentes-mundo</a>

Y estaba en ese elemento 114538, que puede parecer poco, pero teniendo en cuenta que el 2% de los más influyentes llega hasta 209602 nombres, es claro que es un mérito importante.

Es más, solo 154 científicos de la UGR están en ese listado, de todas las áreas, y estoy posicionado cerca de la mitad de la lista según la lista ordenada de Stanford, en mejor posición que investigadores con más experiencia y catedráticos reconocidos, lo cual es todo un logro 👍.

Configurando Emacs desde cero

2023-09-05T00:00:00+00:00

Estaba este verano con unos pocos días libres, y pensando en un curso sobre Emacs, y tras la versión 29.1. decidí hacer una configuración por defecto. Bueno, de cero de cero... ya he estado usando spacemacs desde hace años, y ya conozco paquetes que suelo usar, así que no partía de cero.

El proceso ha sido mucho más sencillo de lo esperado, a partir de un fichero .org siguiendo los consejos de https://github.com/frap/emacs-literate.

La configuración está disponible y explicada en /emacs/</a>, generado también a partir del fichero .org (usando babel genero tanto el fichero init.el como la documentación). Lo bueno es que es fácil poner como comentarios, ..., y adaptarlo usando un control de versiones.

Lo he dividido en:

Configuración general, sin paquetes. a) Configurar la carga de paquetes. b) Quitar la página inicial, scroll inicial. c) Activar por defecto la papelera. d) Pequeños cambios: Hora, quitar algunos mensajes de confirmación, numerar las líneas, ... </li>

Paquetes que considero imprescindibles:
a) Mostrar la letras, usando which-key</a>. b) Mejorar el undo con undo-tree</a> c) Ficheros recientes recentf</a>. d) Marcar fin de paréntesis: Smartparents</a>. e) Vterm para consola. </li>
Distintos formatos (también imprescindible): Epub, PDF, Markdown, ... </li>
Manejo de directorios y ficheros: </li> </ul>
a) Poder filtrar cómodamente con dired-narrow</a>. b) Uso de directorios en dired. c) Flexibilidad de ordenación con dired-quick-sort</a>.

Añadiendo referencias con Zola y Bibtex

2023-08-17T00:00:00+00:00

Hace mucho que no publico en el Blog por falta de tiempo (y de ganas en vacaciones).

Pero acabo de retocarlo para añadir las publicaciones, y como es algo que por mucho que he buscado en Internet no he encontrado nada, lo publico aquí.

A continuación la guía de cómo listar automáticamente publicaciones usando Bibtex y Zola.

Lo primero ha sido crear un fichero .bib con todas mis publicaciones. Por suerte ha sido lo más fácil, he usado Scopus</a> para ello.

Una vez copiado en un directorio /data/ he creado una página con una plantilla nueva, paper_lists.html.

El grueso de dicha página es la instrucción siguiente en la cabecera:

template = "papers_list.html"
</code></pre>
A continuación vamos a ver el fichero papers_list.html</code>:</p>
Primero cargo el fichero en la variable data</em>:</p>
{% set data = load_data(path="/data/all.bib", format="bibtex") -%}
</code></pre>
En data.bibliographies</code> tengo un vector de publicaciones. Aparte del atributo entry_type</code> que indica el tipo de publicación (yo filtro por "ARTICLE") está el atributo tags</code> que contiene los típicos atributos de un paper: title, author, journal, year, volume, pages, ...</p>
Primero hago un filtrado por los artículos ordenados por año:</p>
{% set sorted_bib = data.bibliographies | filter(attribute="entry_type", value="ARTICLE") %}
{% for bib in sorted_bib | sort(attribute="tags.year") | reverse %}
...
{% endfor %}
</code></pre>
Dado que quiero mostrarlo por año, quiero mostrar sólo el año si cambia respecto al anterior. Para ello uso una variable global last_year</code>:</p>
{% if last_year != bib.tags.year %}
	    <h1 class="title">{{bib.tags.year}}</h1>
	    {% set_global last_year = bib.tags.year %}
{% endif %}
</code></pre>
El resto es sencillo, es simplemente utilizar bib.tags</code>. He intentado usar macros, pero tiene limitaciones.</p>
A continuación muestro el código en completo.</p>
{% set data = load_data(path="/data/all.bib", format="bibtex") -%}

{% if data %}
<section class="section">
    <div class="container">
	<div class="columns is-centered">
	    {% set_global last_year="2000" %}
	<div class="column is-9">
	    <h2 class="title">{{trans(key="papers",lang=lang)}}</h2>
	    {% set sorted_bib = data.bibliographies | filter(attribute="entry_type", value="ARTICLE") %}
	    {% for bib in sorted_bib | sort(attribute="tags.year") | reverse %}
	    {% if last_year != bib.tags.year %}
	    <h1 class="title">{{bib.tags.year}}</h1>
	       {% set_global last_year = bib.tags.year %}
	    {% endif %}
	    {# __tera_context#}
	    <article class="box">
            <h2>
		<b>
		{% if bib.tags.doi %}
		<a class="has-text-dark" href='http://dx.doi.org/{{bib.tags.doi}}' target="_blank">
            {{ bib.tags.title }}
		</a>
		{% else %}
		{{ bib.tags.title }}
		{% endif %}
		</b>{{ bib.tags.author}}. {{ bib.tags.journal}}. vol: {{bib.tags.volume}}, {% if bib.tags.pages %}pages: {{bib.tags.pages}}{% else %} In Press {% endif %} ({{bib.tags.year}}).
		{#
		{% if bib.tags.note != "cited By 0" %}
		{{bib.tags.note}}
		{% else %}
		{{bib.tags.note}}
		{% endif %}
		#}
		{% if bib.tags.note and bib.tags.note != "Cited By 0" %}
		{% set citations = bib.tags.note | split(pat=" ") | last | int %}
		{% if citations >= 5  %}
		<b>{{trans(key="citations", lang=lang)}}: {{ citations }}</b>
		{% endif %}
		{% endif %}
	    </h2>
	</article>
	  {% endfor %}
      </div>
    </div>
</section>
{% endif %}
</code></pre>


Charlas y Material Docente
2023-03-31T00:00:00+00:00
En esta entrada muestro material docente o de divulgación, es una recopilación de los distintos repositorios que poseo. Antes de utilizar cualquiera de ellos, consulte su licencia correspondiente.</p>
Material Docente oficial</h1>
A continuación muestro material más oficial</p>

Material de la asignatura de Metaheurísticas</a>. Se muestra tanto el material de teoría como de prácticas para la asignatura de Metaheurísticas del Grado de Ingeniería Informática de la Universidad de Granada. Dentro del curso se usa la plataforma Moodle, pero este material se replica en la web de nuestro grupo de investigación.</li>
</ul>
Material sobre asignatura de Preprocesamiento</em> en el Máster de Ciencias de Datos:</p>


Transparencias</a></p>
</li>

Código fuente</a></p>
</li>
</ul>
Charlas</h1>
Charlas Docente</h2>
Gestionando tu proyecto con MLFlow</h3>
Transparencia de la charla Gestionando tu proyecto con MLFlow</em> dada en PyDataGR en Diciembre.</p>

    
    
    
</center>

Transparencias en formato web</a></li>
Recurso en Github</a></li>
</ul>
La estadística como aliada en la experimentación de algoritmos evolutivos</h3>
Transparencias de charla en el curso de Algoritmos Evolutivos</em> del Máster de Ingeniería del Software e Inteligencia Artificial</em> de la Universidad de Málaga, UMA.</p>

    
    
    
</center>
Transparencias</a></p>
Divulgativas sobre Inteligencia Artificial</h2>
Inteligencia artificial en el siglo XXI: Qué nos puede ofrecer, y de qué tenemos que tener cuidado</h3>

    
    
    
</center>

Transparencias en Zenodo</a>.</li>
</ul>
La Naturaleza, inspiradora de Inteligencia Artificial</h3>

    
    
    
</center>

Transparencias en Zenodo</a>.</li>
Software Demo sobre Algoritmo Bio-Inspirado</a></li>
Software Demo de Identificación de Animal</a></li>
</ul>

</h2>
About me</h3>

    
    
    
</center>

Transparencias</a></li>
</ul>
Sobre Software Libre</h2>
Charla sobre Polars (presentada en PyData 14/03/2024)</p>

    
    
    
</center>

Transparencias</a></li>
</ul>
Charla sobre Mastodon (colaboración con la Oficina de Software Libre, en 2023)</p>

    
    
    
</center>

Transparencias</a></li>
</ul>
Curso corto de Machine Learning de un plan Erasmus+ (Inglés)</p>

Transparencias</a></li>
</ul>
Taller en el PyConES del 2022</p>

Transparencias</a></li>
</ul>
Charla en el JuliaCon 2022 (Inglés) sobre mi experiencia docente usando Julia</p>

Vídeo</a></li>
</ul>
Charla en el JuliaCon 2021 (Inglés) sobre mi utilidad DaemonMode, que permite ejecutar rápidamente Julia para scripts.</p>

Vídeo</a></li>
Package</a></li>
Cliente ligero (en Nim)</a></li>
</ul>
Presentación oficial en el PlutoCon 2021 (Inglés)</p>


Transparencias</a></p>
</li>

Vídeo</a></p>
</li>
</ul>
Charla sobre FastAPI (en Instituto de FP invitado, y luego en la ETSIIT de la UGR en 2023)</p>

    
    
    
</center>

Transparencias</a></li>
</ul>
Taller sobre Pandoc (colaboración con la Oficina de Software Libre) en 2022</p>

    
    
    
</center>

Transparencias</a></li>
</ul>


Poniendo calificaciones con Emacs
2023-01-27T00:00:00+00:00
A estas alturas a nadie le extrañará que soy un gran fan de Emacs.</p>
Cada vez lo uso más para corregir a los alumnos. Tiene grandes ventajas:</p>
En presentaciones (como esta mañana) me resulta muy cómodo tener la pantalla compartida en un buffer el pdf (que puedo abrir incluso aunque me lo mandasen en zip) y en otro el fichero con los comentarios.</p>
Pero lo más interesante son las calificaciones, gracias a dos grandes descubrimientos recientes:</p>
Explico un poco cómo corrijo.</p>
Comentarios para cada estudiante</h2>
Tengo un apartado en el que pongo comentarios por cada estudiante.</p>
* Comentarios

** Estudiante1

- Ej1: ...
- Ej2: ...
...

** Estudiante2

- Ej1: ...
- Ej2: ...
</code></pre>
Usando este formato me resulta muy cómodo de mover. Además, la parte Ej1, ... lo guardo como plantilla y lo copio para cada estudiante.</p>
Pero lo más interesante son las tablas, suelo corregir ponderando cada prueba
en función de su puntuación, y me viene muy bien.</p>
Puntuando a los alumnos</h2>
Creo una fila por cada estudiante, y una columna por prueba, marcando cada casilla con un valor entre 0 y 1. 0 indica totalmente mal,0.5 sería que le doy la mitad de la puntuación de la prueba correspondiente, y 1 toda la puntuación.</p>
Por ejemplo, supongamos tres pruebas en el que la media final sería que el primero vale 3 puntos, el siguiente 4 y el tercero otros 3 puntos, creo la tabla de la siguiente forma:</p>
#+name: grupoE
| Nombre     | Apellidos |  3 |    4 |  3 | Total |
|            |           | P1 |   P2 | P3 |       |
|------------+-----------+----+------+----+-------|
| Apellidos1 | Nombre1   |  1 |  0.5 |  0 |   5.0 |
| Apellidos2 | Nombre2   |  0 | 0.75 |  1 |   6.0 |
| Apellidos3 | Nombre3   |  0 |    0 |  1 |   3.0 |
|            
#+TBLFM: $6=vsum((@1$3..@1$5)*($3..$5));%.1f
</code></pre>
La primera fila almacena la puntuación de cada punto, de forma que la puntuación final se puede
actualizar de forma automática al cambiar tanto la ponderación como la calificación de estudiantes (Con C-c C-c</code>).</p>
En https://orgmode.org/worg/org-tutorials/org-spreadsheet-lisp-formulas.html</a> hay una buena introducción del uso de fórmulas, que un día complementaré 😊.</p>
Las tablas pueden también ordenarse, basta con ponerse en la columna a ordenar (como apellidos), y org-table-sort-lines para ordenar (, t s</em> en spacemacs). Hay dos enfoques muy útiles:</p>


Ordenar alfabéticamente, como ponerse en la columna Apellidos</code> y tras org-table-sort-lines</code> seleccionar la a</code> para ordenar alfabéticamente.</p>
</li>

Ordenar por puntuación, ponerse en la columna Total</code>, y tras org-table-sort-lines</code> seleccionar la n</code> para ordenar por puntuación.</p>
</li>
</ul>
Tablas resumen</h2>
Una utilidad muy cómoda es el paquete orgtbl-aggregate</a> que permite hacer tablas resúmenes de forma muy cómoda.</p>
Por ejemplo, si quisiésemos una tabla adicional solo con la final:</p>
#+name: final
#+BEGIN: aggregate :table "grupoE" :cols "Nombre Apellidos Total;'Calificación';%1f"
#+END:
</code></pre>
Como se ve, se menciona una tabla externa a través de su nombre (en #+name: ...</code>) y listar las
columnas que nos interesan.</p>
Y al pulsar C-c C-c</code> en el begin, se completa automáticamente:</p>
#+BEGIN: aggregate :table "grupoE" :cols "Nombre Apellidos Total;'Calificación';%1f"
| Nombre     | Apellidos | Calificación |
|------------+-----------+--------------|
| Apellidos1 | Nombre1   |          5.0 |
| Apellidos2 | Nombre2   |          6.0 |
| Apellidos3 | Nombre3   |          3.0 |
#+END:
</code></pre>
Como se puede ver también se puede renombrar los atributos como se muestra en el ejemplo usando el ;</code>
y las cursivas.</p>
Al cambiar la tabla anterior, se puede ejecutar C-c C-c y se actualiza automáticamente.</p>
Filtrando</h4>
También se puede seleccionar. Por ejemplo, si queremos mostrar sólo los aprobados podemos limitar la
búsqueda usando :cond</code>. En este caso es necesario un poco de emacs lisp, pero limitar la puntuación
es sencillo (sólo hay que acordarse de que hay que convertir la cadena en número para comparar).</p>
#+name: aprobados
#+BEGIN: aggregate :table "grupoE" :cond(>= (string-to-number Total) 5.0):cols "Nombre Apellidos Total;'Calificación';%1f"
#+END:
</code></pre>
Al pulsar C-c C-c</code> se completa automáticamente únicamente con los aprobados.</p>
#+name: aprobados
#+BEGIN: aggregate :table "grupoE" :cond(>= (string-to-number Total) 5.0):cols "Nombre Apellidos Total;'Calificación';%1f"
| Nombre     | Apellidos | Calificación |
|------------+-----------+--------------|
| Apellidos1 | Nombre1   |          5.0 |
| Apellidos2 | Nombre2   |          6.0 |
#+END:
</code></pre>
Ordenando tablas resumen</h4>
Se puede ordenar directamente las tablas resumen usando ^a</code> para alfabético, o ^n</code> para ordenar
numéricamente (y ^A</code> y ^N</code> para ordenarlo en forma descendente).</p>
#+BEGIN: aggregate :table "grupoE" :cols "Nombre Apellidos Total;^N;'Calificación';%1f"
#+END:
</code></pre>
Que al pulsar C-c C-c</code> automáticamente completa de forma aleatoria:</p>
#+BEGIN: aggregate :table "grupoE" :cols "Nombre Apellidos Total;^N;'Calificación';%1f"
| Nombre     | Apellidos | Calificación |
|------------+-----------+--------------|
| Apellidos2 | Nombre2   |          6.0 |
| Apellidos1 | Nombre1   |          5.0 |
| Apellidos3 | Nombre3   |          3.0 |
#+END:
</code></pre>
Completando información</h4>
Vamos a completar la tabla original con el número de estudiantes evaluados (números de filas), y la
media de las calificaciones:</p>

Vamos a añadir el número de evaluaciones:</li>
</ul>
#+TBLFM: @>$2=vlen(@I..@II)</code></p>
Esta línea añadiría en la última fila (@></code>) y segunda columna ($2</code>) el número de elementos. Para
no contar los apellidos, se puede sumar sólo las regiones separadas entre dos líneas verticales
(entre @I</code> y @II</code>).</p>

Hacer el promedio:</li>
</ul>
Es muy fácil hacer una fila promedio usando vmean</code>:</p>
#+TBLFM: @>$6=vmean(@I$6..@II$6)</code></p>
Combinándolo todo:</p>
| Nombre     | Apellidos |  3 |    4 |  3 | Total |
|            |           | P1 |   P2 | P3 |       |
|------------+-----------+----+------+----+-------|
| Apellidos1 | Nombre1   |  1 |  0.5 |  0 |   5.0 |
| Apellidos2 | Nombre2   |  0 | 0.75 |  1 |   6.0 |
| Apellidos3 | Nombre3   |  0 |    0 |  1 |   3.0 |
|------------+-----------+----+------+----+-------|
| Total      | 3         |    |      |    |  4.67 |
#+TBLFM: $6=vsum((@1$3..@1$5)*($3..$5));%.1f::@>$2=vlen(@I..@II)::@>$6=vmean(@I$6..@II$6);%.2f
</code></pre>
Calculando datos</h4>
En las tablas resumen se pueden añadir fórmulas, y se aplican automáticamente.</p>
Voy a hacer una tabla que indica los aprobados, los suspensos y el ratio de aprobados:</p>
#+begin: aggregate :table "aprobados" :cols "count();'Aprobados' count();'Suspensos';%.0f count();'Ratio'"
| Aprobados | Suspensos | Ratio |
|-----------+-----------+-------|
|         2 |         1 |  66.7 |
#+TBLFM: $2=remote(grupoE,@>$2)-$1::$3=$1/($1+$2)%; %.1f
#+end:
</code></pre>
Remote permite acceder a una columna de otra tabla, en este caso lo usamos para acceder al total de
filas. El %</code> permite mostrar el porcentaje, si no estuviese habría que multiplicar por 100. El
%.1f</code> indica que se desea un decimal.</p>
Espero que estos consejos os hayan dado ideas de cómo usar Emacs y org-table para hacer cosas chulas.</p>


Creando notebooks desde Markdown
2022-11-03T00:00:00+00:00
El uso de Notebooks en Python es muy útil, especialmente para enseñanza.
Sin embargo, aunque el interfaz web (y el uso de
EIN</a> desde Emacs), siempre me
resulta un poco "latazo" tener que moverme entre celdas, intercalando texto en
Markdown</code> y en Python</code> (o Julia</code>).</p>
Afortunadamente, existen alternativas. La más genérica y que me gusta más se
llama jupytext</a> y permite convertir
un fichero markdown en un notebook.</p>
La sintaxis es sencilla, el texto en claro pasará a ser celdas markdown, y el
código en Python pasará a ser celdas de código.</p>
Por ejemplo:</p>
### Creando DataFrames desde cero

Se puede crear a partir de un simple `diccionario`.

En el ejemplo tenemos un puesto de frutas que vende manzanas y naranjas. Queremos una columna por cada fruta y una fila por cada compra de un cliente.


```python
data = {
    'apples': [3, 2, 0, 1],
    'oranges': [0, 3, 7, 2],
    'propina': ['si', 'no', 'si', 'si']
}
```

```python
purchases = pd.DataFrame(data)

purchases
```

El **Indice** de este DataFrame se creó automaticamente al iniciarlo, usando los números0-3, pero podemos asignar los que queramos.
</pre>
Quedaría con dos celdas markdown al principio y final, y dos celdas de código en
medio:</p>
</p>
Para compilar los distintos ficheros markdown a notebook uso los siguientes
ficheros.</p>

Un fichero makefile</strong> que compila automáticamente todos los ficheros md a notebook.</li>
</ul>
files:=$(wildcard *.md) # 1 line
OBJ:=$(files:.md=.ipynb) # 2 line

all: $(OBJ)

%.ipynb: %.md
	jupytext $< --update --to notebook # update es para mantener los IDs en el fichero.

clean:
	rm *.ipynb

</code></pre>

Un pequeño script run.sh</strong> que permite ejecutarlo cuando un fichero cambia
gracias al excelente programa
watchexec</a>, aunque otros programas como
entr</a> también valdría:</li>
</ul>
watchexec -e md make
</code></pre>
De esta manera, cuando cualquier fichero con extensión markdown (ignora el
resto) es modificado, automáticamente llama a make, que cambiará el notebook
correspondiente.</p>


Charla en el PyConES
2022-08-18T00:00:00+00:00
Este año vuelvo a contribuir en el congreso nacional de Python (PythonConES).</p>

    
    
    
</center>
Prepararé un taller de dos horas sobre identificación de cuellos de botella en
un programa en Python y mejora de eficiencia. Se me ocurrió dicho taller viendo
la experiencia de alumnos míos en Metaheurísticas, que escogieron el uso de
Python, y por no tener suficiente experiencia el tiempo de ejecución era
demasiado largo. Ya informé que no recomendaba usar Python si no se tenía algo
de experiencia sobre código eficiente en Python, pero algunos no siguieron mi
recomendación y se encontraron con problemas. Y luego pensando, decidí que
estaría bien un taller sobre lo que debería de saber para poder haberlo hecho
bien.</p>
La charla será el próximo día 30 de Septiembre de 15:30-17:30 en la
ETSIIT</a>. Puedes consultarlo en el Horario del
PyConES</a>. También
supongo que será difundido por streaming</em>, y tras la charla se colgará, pondré
el enlace en cuanto esté disponible para quien no pueda asistir pueda verlo luego.</p>
Aprovecho para animaros a asistir, que tiene charlas muy interesantes, y los
organizadores son colegas 😉.</p>
A continuación describo más en detalle la charla:</p>
Determinaremos el código que supone el mayor consumo de recursos (usando un
profile). También veremos cómo podemos optimizar las partes críticas usando
distintas técnicas. Se espera que tras el taller los asistentes sepan a
identificar los cuellos de botella de sus propios programas/librerías, y
conozcan distintas opciones para poder optimizarlos.</p>
El taller consta de de un enfoque práctico, en el que se verán el uso de las
librerías y técnicas sobre algunos ejemplos prácticos. En particular se verá:</p>

Hacer un profile de un programa para detectar cuellos de botella.</li>
Hacer un profile desde un notebook.</li>
</ul>
Una vez identificado el cuello de botella, pasaremos optimizarlo. Para ello,
aparte de ciertos consejos de implementación, se mostrará cómo pueden reducirse
utilizando algunas librerías eficientes y cython para llamar a código en C/C++.
Dada la duración no se explicarán en detalle esas librerías, pero sí servirá
para darlas a conocer a quien no las conozcan y mostrar cómo adaptando un
pequeño porcentaje del código se pueden obtener muchos mejores resultados.</p>
Las librerías que veremos son:</p>

Librerías cProfile de la librería estándar.</li>
pprofile, mejor rendimiento.</li>
scalene, una librería de profile moderna y con muchas características.</li>
Aplicación de scipy y/o numpy para optimizar código.</li>
Introducir numba y PyPy.</li>
cython para optimizar partes críticas.</li>
</ul>
https://charlas.2022.es.pycon.org/pycones2022/talk/VTQDSZ/</a></p>


Charla en JuliaCon2022
2022-07-27T00:00:00+00:00
Hoy se verá mi charla en el JuliaCon 2022, sobre mis experiencias docentes
usando Julia.</p>
Se puede ver aquí:
https://live.juliacon.org/talk/KGLNUH</a></p>
Después de la hora de la charla, está libremente disponible en Youtube.</p>
El código fuente de las demos está disponible en:
https://gitlab.com/daniel.molina/mh_demos/</a></p>


Miro el móvil
2022-07-09T00:00:00+00:00
Miro el móvil

solo para ver el fondo de pantalla

para ver tu cara

tu sonrisa de un tiempo que se fue.\</p>
Miro el móvil

esperando tus mensajes,

mensajes que no llegan

porque te perdí.\</p>
Miro el móvil
porque no me acompañas,

porque te has ido,

y el pasado que atesora

me acompaña en mi soledad.</p>


Un nuevo inicio
2022-06-28T00:00:00+00:00
Sé que tengo el blog muy parado, y creo saber por qué. El motivo es el idioma.</p>
No es que no sepa inglés, la verdad es que lo domino cada vez más, pero es algo
que me echa para atrás a la hora de escribir en mis propio tiempo libre. Por
tanto, he decidido empezar a escribir en español/andaluz/granaíno. De esa forma
espero animarme a escribir más, porque tengo temas para hacerlo y nunca lo acabo
haciendo.</p>
Así pues, aquí empieza mi nuevo inicio.</p>


Sobre mi
2020-07-01T00:00:00+00:00

    
    ¿Quien es ese loco?</figcaption>
</figure>
Soy Titular de la Universidad de Granada, especializado en Inteligencia
Artificial y Metaheurísticas. Como mucha gente, tengo varios roles:</p>


Como investigador, tengo un índice h de 23, con más de 24 trabajos (más del
90% en Q1), y más de 7000 citas. En la portada, puede consultar mis
publicaciones en ORCID y en Google Schoolar, y pondré un enlace con mis
publicaciones (en muchos casos con el PDF disponible, escribame si
necesitase alguno que no apareciese). Además, he sido hasta 2019 el Chair
del IEEE CIS Task Force on Large-Scale Global
Optimization</a>, ya que es un tipo de optimización en el
que tengo especial interés (he ganado dos competiciones internacionales
sobre LSGO, en 2010 y más recientemente en 2018). Formo parte del Instituto
Andaluz Interuniversitario en Data Science and Computational Intelligence</em>
DaSCI</a>.</p>
</li>

Como profesor, enseño en la Universidad de Granada</a>, en
la Escuela Técnica Superior de Ingeniería</a>, y
durante más de 10 años fui profesor de la Universidad de Cádiz, en donde
dejé parte de mi corazón (esa gente fueron más amigos que colegas).</p>
</li>

Como informático adoro programar, en distintos lenguajes (C++, Java, ...) y
en particular tengo predilección por Python y otros lenguajes prometedores
(como Rust o Julia).</p>
</li>

Me defino a mí mismo como Linuxero, Linux es el único Sistema Operativo de
mi ordenador personal por más de 15 años. También soy un feliz usuario de
Emacs (y anteriormente de Vim, adoro ambos). Además, defensor del Software
Libre</a> (llegué a ser durante
años Secretario de la Oficina de Software Libre, OSLUCA, de la Universidad
de Cádiz).</p>
</li>

Como persona del mundo real, adoro leer libros de todo tipo, ver películas y
pasar la mayor parte de mi tiempo libre con mi novia Amalia ❤️.</p>
</li>
</ul>


Sobre enseñanza online
2020-03-27T00:00:00+00:00
Estos días nos encontrados encerrados en nuestras casas por el coronavirus
(COVID-19), por lo que en mi universidad (en  Granada), como en el resto de
universidades de España, tuvimos que convertirnos en expertos en enseñanza
online</em> en un fín de semana.</p>


Introducción a Julia
2020-01-20T00:00:00+00:00
El año pasado empecé a trabajar en un lenguaje de programación prometedor,
Julia</a>.</p>
Incluso dí una charla orientada a personas con conocimientos de programación
(lo comparo mucho en la charla con Python).</p>
Charla en Castellano</a>
</p>
The resources of that talk are available at Github
Repository</a>.</p>


Fill-more o la importancia de leer la documentación
2017-12-15T00:00:00+00:00
Me encanta</strong>* Emacs y el modo auto-fill. Cuando trabajo lo uso siempre para
hacer más fácil leer el texto (con un pequeño valor, con 80 o 100). Luego, si
tengo que copiarlo a un documento Word (cuando colaboro con otros/as) o en un
texto  (como someter una revisión) simplemene ajusto el fill-column</code> a un valor
muy alto (2000 o similar), con C-x f, y luego copio todo el texto.</p>
Hasta ahora había sufrido en silencio un pequeño problema en modo texto
text-mode</em> (no en org-mode). Si pones</p>
Texto.

- Item 1.
- Item 2.
</code></pre>
Después del fill-mode</code>, tienes:</p>
Text.

- Item 1 Item 2.
</code></pre>
Y para arreglarlo tienes que poner una línea entre ambas:</p>
Texto.

- Item 1.

- Item 2.
</code></pre>
(La línea entre Teto y el primer item también es necesaria).</p>
Pensé que era algo inevitable, pero leyendo la documentación,</p>
https://www.emacswiki.org/emacs/FillParagraph</a></p>
He aprendido que con una simple línea en elisp ese comportamiento se arregla:</p>
;; The original value is "\f\\|[      ]*$", so we add the bullets (-), (+), and (*).
;; There is no need for "^" as the regexp is matched at the beginning of line.
(setq paragraph-start "\f\\|[ \t]*$\\|[ \t]*[-+*] ")
</code></pre>
Debo de comprobar la documentación disponible más a menudo :-).</p>


Elfeed: Usando emacs para leer RSS
2017-10-12T00:00:00+00:00
En los últimos años he usado Emacs para casi todas mis tareas diarias:</p>

Leyendo mis emails (con mu4e</a>).</li>
Creando las transparencias de mis cursos usando org-beamer o pandoc.</li>
Usando dired para navegar por el sistema de ficheros.</li>
Publicar este blog. La nueva versión usa zola</a> y es
libremente accesible codeberg</a>.</li>
</ul>
Lo último en integrar en emacs es leer blogs y noticias de fuentes RSS.
Añadir elfeed</a> y
elfeed-org</a> fui capaz de crear RSS. elfeed-org
es muy simple, y permite añadir las fuentes como item en org-mode:</p>
- Blogs                                                              :elfeed:

  - https://www.meneame.net/rss                                  :news:portada:
  - https://www.meneame.net/rss?status=queued                            :news:
  - http://planet.emacsen.org/atom.xml                                :emacs:
  - https://www.reddit.com/r/programming/.rss                     :programming:
  ...
</code></pre>
Las etiquetas para cada fuente serán compartidas por todos los artículos.</p>
Luego, cargando elfeed</strong>, puede ser obtenido una pantalla mostrando los
distintos artículos.</p>

    
    Prueba de elfeed</figcaption>
</figure>
Y seleccionando el artículo, puede ser abierto, leído y abierto usando el
navegador por defecto.</p>

    
    Lectura de artículo con elfeed</figcaption>
</figure>
Mis opiniones sobre elfeed:</p>


Muy simple de usar.</p>
</li>

El uso de etiquetas es muy poderoso, no solo reciben las etiquetas de la
categoría, puedes añadir las que quieras.</p>
</li>

El filtro de búsqueda es simple y potente, puedes filtrar tanto por fechas
como por etiquetasa.</p>
</li>

El filtro de búsqueda se puede guardar en el marcapáginas (bookmark</em>), usando
C-x r b puede verse los artículos usando un filtro específico.</p>
</li>
</ul>
En resumen, elfeed</strong> ha sido un gran descubrimiento. Si usas emacs, dale un
intento.</p>


Mejorando el rendimiento en Python
2012-07-15T00:00:00+00:00
Todo el código fuente de este post está disponible en github</a>.</p>
Tengo predilección por Python. Para mí, es un gran lenguaje para crear prototipos en
muchas áreas. Para mi trabajo de investigación, suelo crear/diseñar algoritmos de optimización continua utilizando
algoritmos evolutivos</a>. Para estos algoritmos, lenguajes como C/C++ o Java son muy utilizados, especialmente por su
buen rendimiento (para publicar, es habitual tener que hacer muchas comparaciones entre algoritmos, por lo que el rendimiento
puede ser crítico. Sin embargo, para probar nuevas ideas, muchos autores utilizan otras herramientas como Mathlab que reduce el
tiempo de desarrollo a costa de un mayor tiempo de computación.</p>
Estoy de acuerdo en que Mathlab es genial para los algoritmos numéricos, pero sigo prefiriendo Python sobre Mathlab, porque me siento más cómodo
con él, y tengo muchas bibliotecas, y es más sencillo llamar a código en otros lenguajes, escrito en C o Java. Eso nos permite
aumentar el rendimiento, y me gusta probar cuánto se puede mejorar.</p>
Hace varios meses, empecé a escribir mi algoritmo más exitoso, Algoritmos Meméticos basados en el Encadenamiento LS</a>, en Python. Tenía varias
dudas sobre el rendimiento, así que empiezo a escribir un elemento, un Algoritmo Genético de Estado Estable, en Python.</p>
Llamando a código C/C++ desde python</h2>
El primer reto que tuve que afrontar fue permitir que mi programa en python utilizara las mismas funciones de referencia que otras implementaciones,
CEC'2005 benchmark</a>.
Este benchmark define las funciones a optimizar, por lo que su función principal es
evaluar mis soluciones, cuando cada solución es un vector de números reales, con un valor real de fitness.
El código del benchmark fue implementado (por sus autores) en C/C++. Por lo tanto, mi código python tiene que llamar al código C++.</p>
Para ello, he utilizado la librería boost::python</a>, que es, en mi opinión, la forma más sencilla de llamar al código C/C++, especialmente
cuando utilizamos el paquete numpy</a>.</p>
En mi caso, es muy sencillo, porque necesito pocas funciones:</p>
#include <boost/python.hpp>
#include <boost/python/numeric.hpp>
#include <boost/python/list.hpp>
#include <iostream>
#include "cec2005/cec2005.h"
#include "cec2005/srandom.h"

using namespace boost::python;

Random r(new SRandom(12345679));

void set_function(int fun, int dim) {
    init_cec2005(&r, fun, dim);
}

double evalua(const numeric::array &el) {
   const tuple &shape = extract<tuple>(el.attr("shape"));
   unsigned n = boost::python::extract<unsigned>(shape[0]);
   double *tmp = new double[n];
  for(unsigned int i = 0; i < n; i++)
    {
      tmp[i] = boost::python::extract<double>(el[i]);
    }
  double result = eval_cec2005(tmp, n);
  delete tmp;
  return result;
}
...

BOOST_PYTHON_MODULE(libpycec2005)
{
    using namespace boost::python;
    numeric::array::set_module_and_type( "numpy", "ndarray");
    def("config", &set_function);
    def("evaluate", &evalua);
    ...
}
</code></pre>
Más información en la buena documentación de boost::python</a>.</p>
Uno puede llamar al código C/C++, hemos implementado el algoritmo en código python.
El código de prueba fue el siguiente:</p>
from ssga import SSGA
from readargs import ArgsCEC05
import libpycec2005 as cec2005
import numpy

def check_dimension(option, opt, value):
    if value not in [2, 10, 30, 50]:
        raise OptionValueError(
            "option %s: invalid dimensionality value: %r" % (opt, value))

def main():
    """
    Main program
    """
    args = ArgsCEC05()

    if  args.hasError:
        args.print_help_exit()

    fun = args.function
    dim = args.dimension

    print "Function: %d" %fun
    print "Dimension: %d" %dim
    cec2005.config(fun, dim)
    domain = cec2005.domain(fun)
    print "Domain: ", domain
    ea = SSGA(domain=domain, size=60, dim=dim, fitness=cec2005.evaluate)

    for x in xrange(25):
        ea.run(maxeval=dim*10000)
        [bestsol, bestfit] = ea.getBest()
        print "BestSol: ", bestsol
        print "BestFitness: %e" %bestfit
        ea.reset()

if __name__ == "__main__":
    main()
</code></pre>
Este código fuente ejecuta el algoritmo 25 veces, y en cada ejecución el algoritmo se detiene cuando se crean 10000*dim soluciones.
Estas condiciones están indicadas en la especificación del benchmark</a>. El único parámetro fue la función (-f, se utilizó la función 1 por
por defecto) y la dimensión (-d) de 10, 30, 50.</p>
Perfilando el tiempo de computación</h2>
¿Cuánto tiempo tarda? He cambiado xrange(25) por xrange(1) y hemos ejecutado su versión actual.
El tiempo final fue de 7 minutos para la dimensión 10, y 21 minutos para la dimensión 30 (para una sola función).</p>
Como me gusta hacer cosas más interesantes, que sólo esperar el tiempo de computación, yo uso el perfil, sólo
una ejecución para la función, para detectar las funciones/método más costosos en tiempo de computación.</p>
python -m cProfile runcec.py -f 1 -d 10
</code></pre>
The output was the following:</p>
        2943600 function calls (2943531 primitive calls) in 31.031 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
....
      1    0.001    0.001    0.126    0.126 ssga.py:1(<module>)
    99940    0.561    0.000   17.463    0.000 ssga.py:109(cross)
        1    0.000    0.000    0.000    0.000 ssga.py:123(reset)
        1    5.559    5.559   51.129   51.129 ssga.py:126(run)
        1    0.000    0.000    0.000    0.000 ssga.py:14(__init__)
        1    0.000    0.000    0.000    0.000 ssga.py:158(getBest)
        1    0.000    0.000    0.000    0.000 ssga.py:31(set_mutation_rate)
    99940    0.730    0.000    1.885    0.000 ssga.py:45(mutation)
    12438    0.286    0.000    0.758    0.000 ssga.py:50(mutationBGA)
        1    0.002    0.002    0.002    0.002 ssga.py:77(initPopulation)
   105883    1.101    0.000    5.604    0.000 ssga.py:89(updateWorst)
        1    0.000    0.000    0.000    0.000 ssga.py:9(SSGA)
    99940    1.049    0.000   20.617    0.000 ssga.py:97(getParents)
...

</code></pre>
Con el perfil podemos observar los métodos más costosos de nuestro código:
getParents (20 segundos), operador de cruce (17 segundos) y updateWorst (5 segundos).
Estos métodos suponen el 85% del tiempo de computación, y los dos primeros el 74%
del tiempo de cálculo.</p>
Optimización del código</h2>
Eso demuestra que la mayor parte del tiempo de computación se debe a una minoría del código,
sólo tres métodos. Si podemos optimizar estos métodos, nuestro código podría
mejorado mucho.</p>
Podemos utilizar de nuevo el paquete boost::python</a>, pero es un poco tedioso utilizarlo. Por lo tanto, hemos
utilizado el paquete cython</a>. Con cython podemos optimizar el código fuente añadiendo
información sobre los tipos.</p>
Por ejemplo, en lugar del siguiente código</p>
import numpy as np

def distance(ind1,ind2):
    """
    Euclidean distance
    ind1 -- first array to compare
    ind2 -- second array to compare

    Return euclidean distance between the individuals

    >>> from numpy.random import rand
    >>> import numpy as np
    >>> dim = 30
    >>> sol = rand(dim)
    >>> distance(sol,sol)
    0.0
    >>> ref=np.zeros(dim)
    >>> dist=distance(sol,ref)
    >>> dist > 0
    True
    >>> dist2 = distance(sol*2,ref)
    >>> 2*dist == dist2
    True
    """
    dif = ind1-ind2
    sum = (dif*dif).sum()
    return math.sqrt(sum)
</code></pre>
Podemos escribir:</p>
cimport numpy as np
cimport cython
DTYPE = np.double
ctypedef np.double_t DTYPE_t
ctypedef np.int_t BTYPE_t

def distance(np.ndarray[DTYPE_t, ndim=1]ind1, np.ndarray[DTYPE_t, ndim=1] ind2):
    """
    Euclidean distance
    ind1 -- first array to compare
    ind2 -- second array to compare

    ....
    """
    cdef np.ndarray[DTYPE_t, ndim=1] dif = ind1-ind2
    cdef double sum = (dif*dif).sum()
    return math.sqrt(sum)
</code></pre>
Podemos ver que sigue siendo muy legible. sólo hemos puesto información sobre el tipo
y dimensión en los parámetros del vector y sobre las variables, usando la palabra clave
cdef.</p>
Veamos como ejemplo el primer método, el operador de cruce, implementado
en el método crossBLX:</p>
import numpy as np
import math

def crossBLX(mother,parent,domain,alpha):
    """
    crossover operator BLX-alpha

    mother -- mother (first individual)
    parent -- parent (second individual)
    domain -- domain to check
    alpha  -- parameter alpha

    Returns the new children following the expression children = random(x-alpha*dif, y+alpha*dif),
                where dif=abs(x,y) and x=lower(mother,parents), y=upper(mother,parents)

    >>> import numpy as np
    >>> low=-5
    >>> upper = 5
    >>> dim=30
    >>> sol = np.array([1,2,3,2,1])
    >>> crossBLX(sol,sol,[low,upper],0)
    array([ 1.,  2.,  3.,  2.,  1.])
    """
    diff = abs(mother-parent)
    dim = mother.size
    I=diff*alpha
    points = np.array([mother,parent])
    A=np.amin(points,axis=0)-I
    B=np.amax(points,axis=0)+I
    children = np.random.uniform(A,B,dim)
    [low,high]=domain
    return np.clip(children, low, high)

</code></pre>
Podemos ver que es muy sencillo de implementar usando numpy, pero sigue siendo muy lento. Con cython he
definido implementar directamente las numerosas operaciones, el siguiente código:</p>
def crossBLX(np.ndarray[DTYPE_t, ndim=1] mother,np.ndarray[DTYPE_t, ndim=1] parent,list domain, double alpha):
    """
    ...
    """
    cdef np.ndarray[DTYPE_t, ndim=1] C, r
    cdef int low, high, dim
    cdef double x, y
    cdef double I, A, B
    cdef unsigned i
    [low,high]=domain
    dim = mother.shape[0]
    C = np.zeros(dim)
    r = random.randreal(0,1,dim)

    for i in range(dim):
        if mother[i] < parent[i]:
           (x,y) = (mother[i],parent[i])
        else:
           (y,x) = (mother[i],parent[i])

        I = alpha*(y-x)
        A=x-I
        B=y+I

        if (A < low):
            A = low
        if (B > high):
            B = high

        C[i] = A+r[i]*(B-A)

    return C

</code></pre>
Es cierto que el código fuente es más complicado, pero sigue siendo muy legible.
He comparado las dos implementaciones para asegurarme de que ambas devuelven los mismos valores.</p>
Midiendo la mejora</h2>
¿Cuánto cuestan estos pequeños cambios en el código?
He vuelto a perfilar el código fuente y me da:</p>
         1020045 function calls (1019976 primitive calls) in 18.003 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
....
        1    0.001    0.001    0.127    0.127 ssga.py:1(<module>)
    99940    0.425    0.000    2.432    0.000 ssga.py:109(cross)
        1    0.000    0.000    0.000    0.000 ssga.py:123(reset)
        1    5.415    5.415   17.864   17.864 ssga.py:126(run)
        1    0.000    0.000    0.000    0.000 ssga.py:14(__init__)
        1    0.000    0.000    0.000    0.000 ssga.py:158(getBest)
        1    0.000    0.000    0.000    0.000 ssga.py:31(set_mutation_rate)
    99940    0.699    0.000    2.006    0.000 ssga.py:45(mutation)
    12544    0.338    0.000    0.929    0.000 ssga.py:50(mutationBGA)
        1    0.002    0.002    0.002    0.002 ssga.py:77(initPopulation)
   105959    0.775    0.000    1.343    0.000 ssga.py:89(updateWorst)
        1    0.000    0.000    0.000    0.000 ssga.py:9(SSGA)
    99940    0.940    0.000    6.665    0.000 ssga.py:97(getParents)
....

</code></pre>
Podemos ver la mejora obtenida.</p>
Method</th> Python</th> Cython</th></tr></thead>

cross          :</td> 17.4</td> 2.4</td></tr>
getParents     :</td> 20.6</td> 6.6</td></tr>
updateWorst    :</td> 5.6</td> 1.3</td></tr>
Total</td> 43.6</td> 10.3</td></tr>
</tbody></table>
El nuevo código tarda sólo un 23% del tiempo de cálculo del código anterior.
Con estos cambios, hemos reducido el tiempo total de 51 segundos a 18 de código.</p>
En perspectiva</h2>
Ahora, ejecuto el código fuente sin el perfil, y pruebo el código fuente obteniendo el
siguiente tiempo:</p>
Method</th> dim=10</th> dim=30</th> dim=50</th></tr></thead>

Python</td> 44s</td> 3240s (54m)</td> --</td></tr>
Cython</td> 10s</td> 28s</td> 48s</td></tr>
Improvement</td> 77%</td> 99%</td> ---</td></tr>
</tbody></table>
En la siguiente tabla, comprobamos el tiempo máximo para una y 25 ejecuciones (el tiempo depende de la
función utilizada).</p>
#functions</th> dim=10</th> dim=30</th> dim=50</th></tr></thead>

1</td> 10s/18s</td> 28s/40s</td> 48s/1m</td></tr>
25</td> 3/7m</td> 15/21m</td> 38m/</td></tr>
</tbody></table>
Así, el tiempo total de cálculo es de 7 minutos para la dimensión 10, y de 21 minutos para la dimensión 30.
Estas cifras son muy aceptables, especialmente porque podemos probar en paralelo las diferentes funciones
en un cluster de ordenadores. Desgraciadamente, una implementación en Mathlab no sólo llevaría más tiempo, sino que
sino que además, por razones de licencia, no podría ejecutarse en paralelo sin límite.</p>
En resumen, podemos utilizar código python, no sólo para crear prototipos experimentales, sino también para crear
prototipos funcionales.</p>
Y sobre el posible problema de las pruebas, he estado trabajando en ello, pero creo que es suficiente para un post,
¿no? :-)</p>
Todo el código referido en el post, tanto en python como en cython, está disponible en github</a>, por si quieres verlo.</p>

Daniel Molina Profile

Estancia en la Universidad de Surrey

Publicaciones en Revistas Internacionales

Visitando Londrina

Listado como uno de los investigadores más influyentes

Configurando Emacs desde cero

Añadiendo referencias con Zola y Bibtex

Charlas y Material Docente

Material Docente oficial</h1> A continuación muestro material más oficial</p>

Charlas</h1> Charlas Docente</h2> Gestionando tu proyecto con MLFlow</h3> Transparencia de la charla Gestionando tu proyecto con MLFlow</em> dada en PyDataGR en Diciembre.</p>

Charlas Docente</h2>

Gestionando tu proyecto con MLFlow</h3> Transparencia de la charla Gestionando tu proyecto con MLFlow</em> dada en PyDataGR en Diciembre.</p>

La estadística como aliada en la experimentación de algoritmos evolutivos</h3> Transparencias de charla en el curso de Algoritmos Evolutivos</em> del Máster de Ingeniería del Software e Inteligencia Artificial</em> de la Universidad de Málaga, UMA.</p>

</h2>

About me</h3> </center> Transparencias</a></li> </ul> Sobre Software Libre</h2> Charla sobre Polars (presentada en PyData 14/03/2024)</p>

Sobre Software Libre</h2> Charla sobre Polars (presentada en PyData 14/03/2024)</p>

Poniendo calificaciones con Emacs

Comentarios para cada estudiante</h2> Tengo un apartado en el que pongo comentarios por cada estudiante.</p>

Creando notebooks desde Markdown

Charla en el PyConES

Charla en JuliaCon2022

Miro el móvil

Un nuevo inicio

Sobre mi

Sobre enseñanza online

Introducción a Julia

Fill-more o la importancia de leer la documentación

Elfeed: Usando emacs para leer RSS

Mejorando el rendimiento en Python

Optimización del código</h2> Eso demuestra que la mayor parte del tiempo de computación se debe a una minoría del código, sólo tres métodos. Si podemos optimizar estos métodos, nuestro código podría mejorado mucho.</p>