Diseño en 3D de un contenedor para proyectos electrónicos


Para el modelado 3D, Tinkercad debería ayudarnos ante cualquier diseño inicial de una manera  más sencilla con el proceso de modelado 3D, tanto es así, que incluso los modeladores experimentados lo hacen  explorando las formas de Tinkercad,  pues curiosamente, una herramienta “simple” como Tinkercad puede conducir a formas complejas. Lógicamente detrás de Tinkercad y de cualquier otro programa de modelado 3D está el código, de modo que a medida que arrastra y suelta formas, los algoritmos complejos están trabajando para calcular cómo aparecerán los gráficos en la pantalla, asi que  también debería ser posible crear figuras geométricas directamente mediante código.

Para aquellos que tienen curiosidad sobre el código, OpenSCAD es una herramienta gratuita de software para explorar el modelado 3d desde esa perspectiva,  resultando  mucho mas eficiente   y concisa   en el  proceso de diseño que cualquier otra herramienta gráfica como por ejemplo Tinkercad.

A diferencia de Tinkercad, OpenSCAD no es una aplicación basada en la web de  modo que si esta interesado  en la herramienta   tendrá que descargarla ( OpenSCAD se puede descargar gartis en http://www.openscad.org y está disponible para Windows, Mac OS X y Linux)   e instalarla en su PC para usarla.

La interfaz OpenSCAD es sencilla  en comparación con Tinkercad ,constando  de sólo tres ventanas, siendo la ventana de la izquierda un editor de texto utilizado para ingresar el código.

panel

Con OpenSCAD está diseñando código,pero no se preocupe: escribir código con Open SCAD es similar al uso de HTML en una página web, siendo el código para crear objetos  autoexplicativo  (por ejemplo, el comando del cubo crea cubos, el comando de esfera crea esferas y el comando del cilindro crea cilindros, etc).

Probablemente haya alrededor de 60 comandos en OpenSCAD, muchos de los cuales  permitirán manipular la geometría ,  como por ejemplo mover, rotar, escalar y usar operaciones booleanas para combinar objetos, pero no se preocupe porque  para modelar  la mayoría de la piezas solo necesitaran  unos pocos comandos como  son union , difference, translate, cylinder o  cube.

Las secuencias de comandos en el lenguaje de OpenSCAD se utilizan para crear modelos en 2D o 3D, veamos a continuacion un ejemplo del diseño de una caja para albergar proyectos electronicos completamente personliazable, para lo cual usaremos el poderoso comando hull () de OpenSCAD y el simple offset () para crear el cuadro de proyecto más fácil de todos.

 Es de destacar que conseguiremos esquinas redondeadas fáciles (sin restas complicadas), aunque en términos de concepto, esto puede no ser «fácil», es fácil en el sentido de que es conciso y demuestra algunos conceptos eficientes.

Conceptos utilizados:

  • Subsistema 2d
    • cuadrado : sqare()
    • compensar: offset()
  • Sistema 3d
    • cáscara: hull()
    • extrusión_lineal:lineal_extrude ()
    • rotate_extrude: rotate_extrude ()
    • escala: scale()
    • redimensionar : resize()
  • Módulos
  • Comprensión de listas

Empiece con las paredes

Comenzamos haciendo las paredes usando el subsistema 2d. Pero antes de hacer esto, agreguemos algunas variables globales que usaremos a lo largo del tutorial. Añádalos a su ide de OpenSCAD. (Los comentarios son para el personalizador)

BOX_W = 80; // Ancho de caja
BOX_L = 120; // Longitud de la caja
BOX_H = 12; // Altura de la caja
SCREW_SIZE = 3; // Tamaño de tornillo en mm
CORNER_RADIUS = 3; // Radio de las esquinas
WALL_THICKNESS = 2; // Espesor de la pared

Luego agregue un cuadrado () después de las variables usando el Ancho y Largo

sqare ([BOX_W, BOX_L]);

Redondearemos las esquinas con el comando offset (), colocaremos este offset () antes del cuadrado ().

offset (r = CORNER_RADIUS) sqare ([BOX_W, BOX_L]);

A continuación, eliminaremos la parte interior, con diferencia () y otro cuadrado (). Restaremos el grosor de la pared para eliminar todo menos la pared.

difference(){
    offset (r = CORNER_RADIUS) sqare ([BOX_W, BOX_L]);
    square ([BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS]);
}

Hay dos cosas que tendremos que ajustar. Primero, la pared interior no está bien posicionada, así que centremos ambos cuadrados

difference(){
    offset(r=CORNER_RADIUS) square( [BOX_W, BOX_L] );
    square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS] );
}

Ahora usemos offset () para agregar un radio interno. Para calcular el radio interior restaremos el espesor de la pared del radio de la esquina.

difference(){
    offset(r=CORNER_RADIUS) 
        square( [BOX_W, BOX_L], center=true );
    offset( r= CORNER_RADIUS - WALL_THICKNESS )
        square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS], center=true );
}

Por último, para la pared, solo necesitamos darle altura. Podemos usar lienar_extrude para dar la altura de la caja. Agregue un linear_extrude () usando BOX_H para el parámetro, en la línea arriba de la diferencia.

linear_extrude( BOX_H )

Añadiendo la parte inferior.

Queremos un fondo que tenga bordes redondeados. Aquí es donde entra hull () podemos usar hull () con cuatro esferas () para crear un rectángulo con bordes redondeados. Queremos agregar cuatro, usamos la comprensión de listas para no tener interminables traducciones ().

Primero crearemos una lista de coordenadas.

coordinates = [[0,0], [0,120], [80,120], [80,0]];

Luego usaremos la variable de coordenadas en un bucle for para iterar usando un bucle for.

for (i = coordinates)

Cada vez que pasemos por el bucle agregaremos una esfera y la trasladaremos por las coordenadas. Aquí está el código completo para agregar:

coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];
for (i = coordinates)
    translate(i) sphere(CORNER_RADIUS);

Ahora pongamos todo el objeto en un casco () Observe cómo no necesita agregar corchetes {} ya que el bucle for es el hijo directo del casco (). Como resultado, el casco funciona con los resultados de for ()

coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];
hull()
   for (i = coordinates)
      translate(i) sphere(CORNER_RADIUS);

Necesitaremos trasladar el casco resultante para que quede debajo de la pared. Agregue una traducción sobre el casco () usando la mitad del ancho de la caja y la mitad de la longitud de la caja. Anotemos también $ fn = 25; en la parte superior de nuestro código para que podamos ver las cosas un poco mejor.

translate ([-BOX_W / 2, -BOX_L / 2])

Podemos agregar cilindros para tornillos de la misma manera que hicimos las cuatro esferas. Ya tenemos las coordenadas de la parte inferior, así que podemos usarlas. pero necesitamos moverlos en algunos.

for (i = coordinates)
   translate(i) 
      difference(){
          cylinder(h=BOX_H,r=CORNER_RADIUS);
          cylinder(h=BOX_H,r=CORNER_RADIUS - SCREW_SIZE);       
}

Usé rend (f6) para que podamos ver los agujeros.

A continuación, debemos mover las publicaciones para que coincidan con el cuadro. coloque un translate () delante del bucle for (). Esto moverá todo el «conjunto» a su posición.

traslate ([-BOX_W / 2, -BOX_L / 2])

Eso nos da cilindros, pero están demasiado cerca del borde, podríamos crear un segundo conjunto de coordenadas para el segundo bucle, pero se vuelve bastante complicado. Se vería así:

coordinates = [[0 + 10,0 + 10], [0 + 10, BOX_L = -10], [BOX_W-10, BOX_L-10], [BOX_W-10,0 + 10]];

En su lugar, usemos resize () y scale () para hacer lo mismo.

Primero use un resize () para establecer las cuatro publicaciones en su posición final. Los valores serán el ancho y el largo entre el centro de las publicaciones. Agregue resize () delante del bucle for () para los cilindros. Para empezar, usaremos valores fijos.

resize ([75,110,0])

Puede notar que las publicaciones se mueven pero se hacen más pequeñas (es un pequeño cambio). Podemos usar la escala para restablecer las publicaciones a su tamaño original. Agregue el comando de escala justo antes de la diferencia para los cilindros.

scale ([BOX_W / 75, BOX_L / 110])

Ahora las publicaciones tienen el tamaño original.

Aquí hay un antes y un después. Realmente es difícil ver la diferencia, pero está ahí.

Creemos una variable y veamos el bloque de código completo. Agregar POST_OFFSET = 10; al principio de su código. Tendremos que restar eso en resize () y scale () del ancho y alto del cuadro, usaremos intermediarios para que sea más fácil de entender. También necesitamos dividir SCREW_SiZE por 2 para que represente un radio, no el diámetro dado. Veamos el código:

POST_OFFSET=10;

... otro código ...

p_w = BOX_W - POST_OFFSET;
p_l = BOX_L - POST_OFFSET;

resize([p_w,p_l,0]) // Mueve las publicaciones desde el borde
    translate([-BOX_W/2,-BOX_L/2,0])
       for (i = coordinates)
           translate(i)
           scale([BOX_W/p_w,BOX_L/p_l])
               difference(){
                 cylinder(h=BOX_H,r=CORNER_RADIUS);
                 cylinder(h=BOX_H,r=SCREW_SIZE/2);
               }POST_OFFSET = 10;



¡Eso es todo lo que hay! Hay algunas mejoras que podemos hacer, pero esto funcionará bastante bien por ahora. Aquí está el código final completo para jugar. Algunos cambios importantes que necesitaríamos son:

  • Establecer el suelo (inferior) en WALL_THICKNESS
  • Usando un valor o cálculo separado para el cilindro exterior del poste

Pero tendremos que tener una parte dos para eso ya que esta publicación se está alargando.

Super_Project_Box$fn=25;
BOX_W = 80; // Box Width
BOX_L = 120;// Box Length
BOX_H = 12; // Box Height

SCREW_SIZE = 1.5; // Screw size radius.

CORNER_RADIUS = 3; // Radius of corners
WALL_THICKNESS = 2;// Wall Thickness

POST_OFFSET=10;

linear_extrude( BOX_H )
    difference(){
        offset(r=CORNER_RADIUS) 
            square( [BOX_W, BOX_L], center=true );
        
        offset( r= CORNER_RADIUS - WALL_THICKNESS )
            square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS], center=true );
    }


coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];

translate ( [-BOX_W/2, -BOX_L/2] )
    hull()
    for (i = coordinates)
        translate(i) sphere(CORNER_RADIUS);

p_w = BOX_W - POST_OFFSET;
p_l = BOX_L - POST_OFFSET;

resize([p_w,p_l,0]) // Move the posts in from the edge
    translate([-BOX_W/2,-BOX_L/2,0])
       for (i = coordinates)
           translate(i)
           scale([BOX_W/p_w,BOX_L/p_l])
               difference(){
                 cylinder(h=BOX_H,r=CORNER_RADIUS);
                 cylinder(h=BOX_H,r=SCREW_SIZE/2);
               }

Mas información en en http://www.openscad.info

Anuncio publicitario

Mejorando un Asus mini PC


Imagine todas las funciones de un PC tradicional de sobremesa en una caja elegante y ultra compacta, con un tamaño ligeramente superior al de la caja de un DVD: eso es realmente un MiniPC . Y si piensa que un all -in-one es mejor opción que un minipc , quizás no sea del todo lo mas acertado, porque el día que se estropee la pantalla o simplemente quiera reemplazar esta por otra mas grande o de mejor calidad no tendremos ninguna opción, así que desde este blog animamos a al menos sospesar este tipo de mini-equipos que podemos colocar perfectamente detrás de nuestro monitor pareciendo prácticamente un all-in-one pero con la seguridad de que podemos colocarlo en la pantalla que deseemos gracias al standar VESA para fijar el mini-pc al monitor

En el caso de ASUS , tenemos el modelo VivoPV con la potencia de su procesador IntelCore i5 3337U y equipado con la tecnología SonicMaster, el VivoPC allana el camino para disfrutar de informática diaria completa y de una experiencia multimedia cinemática de gran realismo. Siéntate y disfruta con las altísimas velocidades de su conectividad Wi-Fi 802.11ac, hasta tres veces superiores a las velocidades wireless-N estándar, y navega por Internet, realiza streaming de contenido multimedia y juega a través de Internet con una estabilidad máxima.

El VivoPC desafía a las convenciones y redefine el diseño de un PC de sobremesa. Sencillo y elegante, su acabado en metal pulido encaja a la perfección en tu salón o en su oficina. No juzgues al VivoPC por su tamaño. Ofrece el mismo rendimiento que tu PC de sobremesa tradicional. El VivoPC permite realizar todo tipo de tareas con la fluidez que espera, desde trabajar con enormes hojas de cálculo hasta disfrutar de vídeos virales.Navegue por sus páginas favoritas o reproduzca películas y música desde bibliotecas en línea con la tecnología Wi-Fi 802.11ac de doble banda. La tecnología Wi-Fi GO! ofrece un control absoluto del VivoPC sin necesidad de levantarte del sofá. Ademas puede transforma su smartphone o tableta en un mando a distancia con la función escritorio remoto y el teclado y ratón virtuales.

El VivoPC hace que las ampliaciones del ordenador resulten sencillas. Su cubierta lateral deslizante permite acceder de un modo rápido y sencillo a los componentes internos, para que amplíe cuando quieras la memoria y el disco duro.

Este equipo incorpora numerosos puertos USB 2.0 y USB 3.0; estos últimos permiten cargar dispositivos externos más rápido y ofrecen velocidades de transferencia 10 veces más rápidas que el estándar USB anterior, para que pueda transferir y sincronizar dispositivos a toda velocidad. El VivoPC incorpora un puerto de salida SPDIF óptico para ofrecer compatibilidad con varios canales de audio. Igualmente, incluye tres salidas de audio e incorpora puertos de salida HDMI y VGA para conectar el ordenador a pantallas o televisores de alta definición.

Extensión del botón de acceso

Si tenemos un mini-pc probablemente anclado detrás de un monitor nos habremos dado cuenta de lo incomodo que puede resultar encenderlo.

Con este diseño 3D simple alargaremos el botón principal para poder encenderlo de un modo mas cómodo para lo cual necesitaremos 2 piezas impresas en 3D ( descargables gratuitamente desde https://www.thingiverse.com/thing:5027079 ) y un muelle (reciclado por ejemplo de un bolígrafo gastado).

Como podemos ver en la imagen el soporte impreso en 3D se fija al monitor con cinta de doble cara de buena calidad a la distancia deseada y luego se introduce la verilla por el orificio intercalando un muelle reciclado .

El diseño esta ajustado para un Asus vivoPV pero puede adaptarse fácilmente a cualquier otro PC

Mejorando la refrigeración

Otro punto que puede mejorarse de estos minipc es el apartado de la refrigeración, pue scon el tiempo tienden a calentarse para lo cual podemos quitarle la tapa y fijarle al chasis inferior un ventilador vertical de los usados en ordenadores portatiles dado que sus medidas son compatibles y el ruido será inapreciable.

El ventilador lo podemos comprar o reciclar de un viejo portátil. Para fijar el ventilador al chasis interno usaremos silicona térmica y un buen adhesivo de de montaje para los laterales . Para las conexiones ignoraremos los cables del sensor de temperatura ( suelen ser cables de color amarillo uy azul ) conectando los otros dos cables rojo y negro a un conector USB: de este modo cuando encendamos el pc se encenderá el ventilador ( y del mismo modo se apagara cuando apaguemos el ordenador).

Nótese que normalmente estos ventiladores suelen funcionar a 12V DC por lo que alimentarlos a 5V DC no lo perjudicara , haciendo así mucho menos ruido pero girando lo suficiente fuerte para que el ordenador siempre esté siempre bien refrigerado sin que lleguemos a notar que este funcionando

Una vez fijado el ventilador podemos pegar la tapa con cinta de doble cara al otro lado del ventilador y bien podemos dejar los laterales libres ( excepto el de salida de aire) o colocar una pieza en 3d que cubra esa parte.

Otras mejoras

Dado que ya entraríamos en otros aspectos mas comerciales, sin duda aumentar el disco (suelen usar discos mini-ssd) o la memoria( llevan memorias de portátil) son otros aspectos que podemos considerar

Instalacion NILMTK con Anaconda 2021


EL NILM o Non-Intrusive Load Monitoring, es decir la desagregación no intrusiva de la demanda . es una técnica computacional para la estimación del consumo individual de diversos dispositivos utilizando para ello la lectura agregada de un único medidor de energía (Smart Meter, SM). Gracias a las ventajas en cuanto instalación , coste e implementación, éste concepto ha tomado relevancia en los últimos años en el ámbito de las Smart Grids, al aportar una estimación de los hábitos de consumo de los clientes sin la necesidad de un despliegue masivo de contadores inteligentes en cada punto de consumo.

En este contexto vamos a ver una herramienta o toolkit open software llamado NILMTK que nos va a ayudar a comparar algoritmos para implementar la desagregación ( además particularmente no contempla un uso diferente a este)

Para el análisis de la desagregación , necesitamos recolectar datos del consumo centralizado , lo cual nos va permitir a creación de un nuevo dataset el cual puede ser analizado usando las funciones de NILMTK lo que permite, por ejemplo, visualizar los datos de potencia en un determinado periodo u obtener estadísticas de energía del dataset.

Posteriormente, en la etapa de preprocesamiento se toman decisiones en línea con los análisis realizados, con el objetivo de preparar correctamente los datos para del entrenamiento de los modelos de desagregación. Básicamente, el entrenamiento de un modelo consiste en enseñarle a reconocer por separado las características de los dispositivos para luego identificarlos dentro de una señal agregada. El entrenamiento contempla el uso de los algoritmos Combinatorial Optimization (CO) y Factorial Hidden Markov Model (FHMM).

El formato de almacenamiento de datos HDF5

HDF5 es un formato de datos jerárquico que se usar en el NILMTK como fuente datos basado en HDF4 y NetCDF (otros dos formatos de datos jerárquicos).El formato de datos jerárquico, versión 5 (HDF5), es un formato de archivo de código abierto que admite datos grandes, complejos y heterogéneos. HDF5 utiliza una estructura similar a un “directorio de archivos” que le permite organizar los datos dentro del archivo de muchas formas estructuradas diferentes, como lo haría con los archivos en su computadora. El formato HDF5 también permite la incrustación de metadatos, lo que lo hace autodescriptivo .

Las organizaciones utilizan HDF5 para diversas necesidades de datos, acceso, informática y redes.

Estructura jerárquica: un directorio de archivos dentro de un archivo

El formato HDF5 se puede considerar como un sistema de archivos contenido y descrito en un solo archivo. Piense en los archivos y carpetas almacenados en su computadora. Es posible que tenga un directorio de datos con algunos datos de temperatura para varios sitios de campo. Estos datos de temperatura se recopilan cada minuto y se resumen cada hora, día y semana. Dentro de un archivo HDF5, puede almacenar un conjunto de datos similar organizado de la misma manera que podría organizar archivos y carpetas en su computadora. Sin embargo, en un archivo HDF5, lo que llamamos “directorios” o “carpetas” en nuestras computadoras, se llaman groupsy lo que llamamos archivos en nuestra computadora datasets.

2 Términos importantes de HDF5

  • Grupo: un elemento similar a una carpeta dentro de un archivo HDF5 que puede contener otros grupos O conjuntos de datos dentro de él.
  • Conjunto de datos: los datos reales contenidos en el archivo HDF5. Los conjuntos de datos se almacenan a menudo (pero no es necesario) dentro de grupos en el archivo.
Una ilustración de una estructura de archivo HDF5 que contiene grupos, conjuntos de datos y metadatos asociados
Un ejemplo de estructura de archivo HDF5 que contiene grupos, conjuntos de datos y metadatos asociados.

Un archivo HDF5 que contiene conjuntos de datos podría estructurarse así:

La ilustración HDF5 de arriba, pero los grupos son sitios NEON y los tipos de sensores y conjuntos de datos se incluyen en los tipos de sensores.
Un ejemplo de estructura de archivo HDF5 que contiene datos para varios sitios de campo y también contiene varios conjuntos de datos (promediados en diferentes intervalos de tiempo).

HDF5 es un formato autodescriptivo

El formato HDF5 es autodescriptivo. Esto significa que cada archivo, grupo y conjunto de datos puede tener metadatos asociados que describen exactamente cuáles son los datos. Siguiendo el ejemplo anterior, podemos incrustar información sobre cada sitio en el archivo, como por ejemplo:

  • El nombre completo y la ubicación X, Y del sitio.
  • Descripción del sitio.
  • Cualquier documentación de interés.

De manera similar, podríamos agregar información sobre cómo se recopilaron los datos en el conjunto de datos, como descripciones del sensor utilizado para recopilar los datos de temperatura. También podemos adjuntar información, a cada conjunto de datos dentro del grupo de sitios, sobre cómo se realizó el promedio y durante qué período de tiempo están disponibles los datos.

Un beneficio clave de tener metadatos adjuntos a cada archivo, grupo y conjunto de datos es que esto facilita la automatización sin la necesidad de un documento de metadatos separado (y adicional). Usando un lenguaje de programación, como R o Python, podemos obtener información de los metadatos que ya están asociados con el conjunto de datos y que podríamos necesitar para procesar el conjunto de datos.

Una ilustración de una estructura de archivos HDF5 con un grupo que contiene dos conjuntos de datos y todos los metadatos asociados
Los archivos HDF5 son autodescriptivos, lo que significa que todos los elementos (el archivo en sí, los grupos y los conjuntos de datos) pueden tener metadatos asociados que describen la información contenida en el elemento.

Subconjunto comprimido y eficiente

El formato HDF5 es un formato comprimido. El tamaño de todos los datos contenidos en HDF5 está optimizado, lo que reduce el tamaño general del archivo. Sin embargo, incluso cuando están comprimidos, los archivos HDF5 a menudo contienen grandes volúmenes de datos y, por lo tanto, pueden ser bastante grandes. Un atributo poderoso de HDF5 es data slicingmediante el cual se puede extraer un subconjunto particular de un conjunto de datos para su procesamiento. Esto significa que no es necesario leer el conjunto de datos completo en la memoria (RAM); muy útil para permitirnos trabajar de manera más eficiente con conjuntos de datos muy grandes (gigabytes o más).

Almacenamiento de datos heterogéneos

Los archivos HDF5 pueden almacenar muchos tipos diferentes de datos dentro del mismo archivo. Por ejemplo, un grupo puede contener un conjunto de conjuntos de datos para contener datos enteros (numéricos) y de texto (cadenas). O bien, un conjunto de datos puede contener tipos de datos heterogéneos (por ejemplo, tanto texto como datos numéricos en un conjunto de datos). Esto significa que HDF5 puede almacenar cualquiera de los siguientes (y más) en un archivo:

  • Datos de temperatura, precipitación y PAR (radiación fotosintética activa) para un sitio o para muchos sitios
  • Un conjunto de imágenes que cubren una o más áreas (cada imagen puede tener asociada información espacial específica, todo en el mismo archivo)
  • Un conjunto de datos espaciales multi o hiperespectral que contiene cientos de bandas.
  • Datos de campo para varios sitios que caracterizan insectos, mamíferos, vegetación y clima.
  • Un conjunto de imágenes que cubren una o más áreas (cada imagen puede tener asociada información espacial única)
  • ¡Y mucho más!

Formato abierto

El formato HDF5 es abierto y de uso gratuito. Las bibliotecas de apoyo (y un visor gratuito) se pueden descargar desde el sitio web de HDF Group . Como tal, HDF5 es ampliamente compatible con una gran cantidad de programas, incluidos lenguajes de programación de código abierto como R y Python, y herramientas de programación comerciales como MatlabIDL. Los datos espaciales que se almacenan en formato HDF5 se pueden utilizar en los programas de SIG y de imagen que incluyen QGISArcGISENVI.

Beneficios de HDF5

  • Autodescripción Los conjuntos de datos con un archivo HDF5 son autodescriptivos. Esto nos permite extraer metadatos de manera eficiente sin necesidad de un documento de metadatos adicional.
  • Admite datos heterogéneos : un archivo HDF5 puede contener diferentes tipos de conjuntos de datos.
  • Admite datos grandes y complejos : HDF5 es un formato comprimido que está diseñado para admitir conjuntos de datos grandes, heterogéneos y complejos.
  • Admite la división de datos: la “división de datos”, o la extracción de partes del conjunto de datos según sea necesario para el análisis, significa que los archivos grandes no necesitan leerse por completo en la memoria o RAM de la computadora.
  • Formato abierto: soporte amplio en las muchas herramientas : debido a que el formato HDF5 es abierto, es compatible con una gran cantidad de lenguajes y herramientas de programación, incluidos lenguajes de código abierto como R y Pythonherramientas SIG abiertas como QGIS.E

Instalación del NILTK

Básicamente aunque NILMTK se puede instalar muy fácilmente en sistemas basados en Linux , es posible instalarlo también desde Windows 11 . Resumidamente necesitaremos instalar Anaconda ( y Git si no lo tiene instalado ) y realizar la identificación de la carga, encontrar el paquete de instalación de NILMTK y registrar el proceso deliberadamente.

Veamos mas en detalle los pasos a seguir:

Instalación de GIT Windows

Hay varias maneras de instalar Git en Windows. La forma más oficial está disponible para ser descargada en el sitio web de Git. Solo tiene que visitar http://git-scm.com/download/win y la descarga empezará automáticamente. Observe que éste proyecto conocido como Git para Windows (también llamado msysGit), es diferente de Git “normal”. Para más información acerca de este proyecto visita http://msysgit.github.io/.

Otra forma de obtener Git fácilmente es mediante la instalación de GitHub para Windows. El instalador incluye la versión de línea de comandos y la interfaz de usuario de Git. Además funciona bien con Powershell y establece correctamente “caching” de credenciales y configuración CRLF adecuada. Puede descargar este instalador del sitio web de GitHub para Windows en http://windows.github.com.

Descarga e instalación de Anaconda

Los entornos virtuales hacen que la organización de paquetes de Python sea pan comido. Además, el proyecto NILMTK ofrece varias versiones de Conda Forge. Primero, consiga Anaconda aquí. 

Seguidamente nos pedira qeu nos registremos
Enseguida empezara la descarga, por lo que nos iremos a la carpeta de Descargas y ejecutaremos el instalador

Ahora deberemos aceptar la licencia para poder proseguir la instalacion

Seleccione una instalación para “Solo yo” a menos que esté instalando para todos los usuarios (lo que requiere privilegios de administrador de Windows) y haga clic en Siguiente.

Seleccione una carpeta de destino para instalar Anaconda y haga clic en el botón Siguiente. Nota: Instale Anaconda en una ruta de directorio que no contenga espacios ni caracteres Unicode..No lo instale como administrador a menos que se requieran privilegios de administrador.

Ahora nos toca Registrar Anaconda3 y mantener por defecto Python 3.8.

A menos que planee instalar y ejecutar múltiples versiones de Anaconda o múltiples versiones de Python, acepte el valor predeterminado y deje esta casilla marcada.

Haga clic en el botón Instalar. Si desea ver los paquetes que está instalando Anaconda, haga clic en Mostrar detalle

Enseguida enseguida empezara la instalacion , lo cual llevarás unos cinco minutos o menos segun el equipo donde este instalando.

Felicidades, acaba de instalar Conda.

Opcional: para instalar PyCharm para Anaconda, haga clic en el enlace a https://www.anaconda.com/pycharm .

O para instalar Anaconda sin PyCharm, haga clic en el botón Siguiente.

Después de una instalación exitosa, verá el cuadro de diálogo “Gracias por instalar Anaconda”:

Si desea leer más sobre Anaconda.org y cómo comenzar con Anaconda, marque las casillas “Tutorial de Anaconda Edición Individual” y “Aprenda más sobre Anaconda”. Haga clic en el botón Finalizar.

Verifique su instalación .Nota: Si está detrás de un proxy de la empresa, es posible que deba realizar una configuración adicional.

Abra una ventana de terminal de conda, crearemos un nuevo entorno de Conda y lo activaremos con los comandos:

conda create --name nilmtk-env 
conda activate nilmtk-env

Si aún no está presente en su instalación de Conda, agregue el conda-forge a la lista de canales:

conda config --add channels conda-forge

Finalmente, instale la última versión de NILMTK de conda-forge :

conda install -c nilmtk nilmtk=0.4.3

Observe que el signo igual no lleva espacios(piense estamos usando Python). La ejecución del comando puede tardar un rato. Mientras tanto, consulte otros paquetes en Forge de NILMTK .

Como puede experimentar algunos problemas posteriores a la instalación con NILMTK y Matplotlib., para solucionarlos, aplique el comando:

conda install matplotlib 

Verificar la instalación Para verificar que Matplotlib está instalado, intente invocar la versión de Matplotlib en Python REPL. Use desde el interprete Python los comandos a continuación que incluyen llamar a .__ version__, un atributo común a la mayoría de los paquetes de Python.

>>> import matplotlib

>>> matplotlib.__version__

Ejemplo de salida:

(nilmtk-env) C:\Users\carlo>python
Python 3.6.13 (default, Sep 7 2021, 06:39:02) [MSC v.1916 64 bit (AMD64)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.

import matplotlib
matplotlib.version
‘3.1.3’

Agregar un kernel de Jupyter

Básicamente, NILMTK ahora está instalado en su ordenador. El siguiente paso involucra los cuadernos de Jupyter. Trabajar con Jupyter abre muchas posibilidades y se dice que es una herramienta imprescindible. Por lo tanto, agregue el entorno NILMTK a Jupyter:

python -m ipykernel install --user --name nilmtk-env --display-name "Python (nilmtk-env)"

Prueba de la instalación

Ha llegado el momento de comprobar su instalación. Antes que nada, cree una nueva carpeta y descargue el conjunto de prueba aleatorio de Github:

123md nilmtk_testcd nilmtk_test  wget https://raw.githubusercontent.com/nilmtk/nilmtk/master/data/random.h5

Como puede comprobar random.h5 es el fichero de de datos en en formato hdf5 .A continuación, levante Jupyter:

1notebook jupyter

Para probar su instalación, intente importar el conjunto de datos aleatorio usando NILMTK y trazar todos los medidores:https://klemenjak.medium.com/media/9ba2be16d331653a7b4093a0fe412434

La salida debe ser:

1MeterGroup (metros =   ElecMeter (instancia = 1, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])   ElecMeter (instancia = 2, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])   ElecMeter (instancia = 3, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])   ElecMeter (instancia = 4, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])   ElecMeter (instancia = 5, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = []) )

¡Felicitaciones! Lo ha logrado. ¡NILMTK parece funcionar según lo previsto! 

La imagen tiene un atributo ALT vacío; su nombre de archivo es pexels-photo-5036278.jpeg

Como subir un proyecto local a github.


Ver las imágenes de origen

GitHub es una plataforma de desarrollo colaborativo para alojar proyectos utilizando el sistema de control de versiones Git. Se utiliza principalmente para la creación de código fuente de programas de ordenador. El software que opera GitHub fue escrito en Ruby on Rails. Desde enero de 2010, GitHub opera bajo el nombre de GitHub, Inc. Anteriormente era conocida como Logical Awesome LLC. El código de los proyectos alojados en GitHub se almacena típicamente de forma pública.

El 4 de junio de 2018 Microsoft compró GitHub por la cantidad de 7500 millones de dólares,​ al inicio el cambio de propietario generó preocupaciones y la salida de algunos proyectos de este repositorio, sin embargo no fueron representativos. GitHub continúa siendo la plataforma más importante de colaboración para proyectos Open Source

Para crear un proyecto desde Github hay al menos dos formas de hacerlo

  • Desde el propio site de Gitub
  • Desde linea de comandos

Crear un proyecto desde la web de github

Creamos un nuevo repositorio en https://github.com. Le damos nombre, descripción, seleccionamos si va a ser un proyecto publico o privado si es el caso, y dejamos el check de crear README sin marcar. Le damos a crear repositorio y con esto ya tenemos el repositorio donde alojaremos nuestro proyecto.

Crear un proyecto desde la terminal del equipo donde esta el proyecto que queremos subir a github

Nos vamos a la carpeta del proyecto y ejecutamos estos comandos.

git init

git add .

git commit -m "first commit"

git remote add origin https://github.com/NOMBRE_USUARIO/NOMBRE_PROYECTO.git

git push -u origin master


Ver las imágenes de origen

Trucos

para eliminar ficheros al hacer push en vez de
git add .
usar
git add -u

para deshacer un git add .
git reset
si seguido de git commit ...
git reset HEAD~
para deshacer varios commit locales que no han sido pushedados:
git reset --hard <codigo del commit>
para obtener el codigo hacer:
git log
para salir del log pulsa q

ERRORES

Ese error que te arroja se refiere a que tu rama remota -alojada en github- posee contenido que tu rama local no contiene.

Si quieres ir un paso más allá y no deseas que se cree ese commit merge automático, existe un método parecido que te crea una estructura de ramas ligeramente diferente, lineal. (Pierdes la trazabilidad de las fusiones de ramas, así que no se recomienda en exceso cuando es trabajo colaborativo… vamos, que hay que saber utilizarlo).

git fetch
git rebase origin/master
git push

Fetch: te trae todos los cambios sin integrarlos (pull los integra, fetch sólo da constancia a tu repositorio local de que en la rama oculta origin/master existe determinado commit). Ósea, digamos que abres ese árbol pero en local, y tu rama de trabajo sigue apuntando a tu commit local y la rama origin/master a los contenidos bajados del remoto. En tu rama de trabajo local no tendrás integrados esos contenidos remotos que sí existen en la rama origin/master.
rebase origin/master : apuntas a origin como nuevo punto inicial para tu rama e integras los cambios de tu commit local. (Si existen conflictos, tendrás que resolverlos)
push : subes esa integración. No se sube tu commit local original, sino la mezcla de ambos.

Dejando una estructura similar a esta, todos al mismo nivel:

º Commit X (previo commit al error)
º Commit 1 (el que existe en remoto y no tienes en local)
º Commit 3 (el merge de commit 1 + tu commit local)

image

Con el ejemplo del gráfico, tu local es el color verde; has seguido desarrollando, mientras paralelamente en la rama azul (remoto) existen otros cambios que no posees.

Como indica el error, te sugiere que primero integres esos cambios en tu rama local, haciendo un git pull.
Si integras los cambios y si no existen conflictos a corregir, se creará automáticamente un último commit con el merge de ambas ramas. Si existen conflictos -te lo indicará- deberás resolverlos antes y luego se creará el commit de merge. Tras ello podrás hacer un git push sin problema.

Eso dejará una estructura de ramas similar a esto (imagínate el commit X abriéndose en 2 y volviéndose a cerrar al llegar al commit merge).

º Commit X (previo commit al error)
ºº Commit 1 (el que existe en remoto y no tienes en local)
ºº Commit 2 (el que existe en local y contiene commit X, pero no commit 1)
º Commit 3 (el merge de commit 1 + commit 2)

image

Como subir un proyecto local a github.


GitHub es una plataforma de desarrollo colaborativo para alojar proyectos utilizando el sistema de control de versiones Git. Se utiliza principalmente para la creación de código fuente de programas de ordenador. El software que opera GitHub fue escrito en Ruby on Rails. Desde enero de 2010, GitHub opera bajo el nombre de GitHub, Inc. Anteriormente era conocida como Logical Awesome LLC. El código de los proyectos alojados en GitHub se almacena típicamente de forma pública.

El 4 de junio de 2018 Microsoft compró GitHub por la cantidad de 7500 millones de dólares,​ al inicio el cambio de propietario generó preocupaciones y la salida de algunos proyectos de este repositorio, sin embargo no fueron representativos. GitHub continúa siendo la plataforma más importante de colaboración para proyectos Open Source

Para subir un proyecto en Github hay al menos dos maneras de hacerlo

  • Desde el interfaz grafico de la web de github
  • Desde linea de comandos

Crear un prooyecto desde la web de Github

Creamos un nuevo repositorio en https://github.com. Le damos nombre, descripción, seleccionamos si va a ser un proyecto publico o privado si es el caso, y dejamos el check de crear README sin marcar. Le damos a crear repositorio y con esto ya tenemos el repositorio donde alojaremos nuestro proyecto.

Crear un proyecto desde la terminal del equipo donde esta el proyecto que queremos subir a github

Nos vamos a la carpeta del proyecto y ejecutamos estos comandos.

git init

git add .

git commit -m "first commit"

git remote add origin https://github.com/NOMBRE_USUARIO/NOMBRE_PROYECTO.git

git push -u origin master

Algunos trucos que nos pueden ayudar

  • Para eliminar ficheros al hacer push en vez degit add .usar
    git add -u
  • para deshacer un git add .
    git reset
    si seguido de git commit ...
    git reset HEAD~
  • Para deshacer varios commit locales que no han sido pushedados:
    git reset --hard <codigo del commit>
    Para obtener el codigo hacer:
    git log
    Para salir del log pulsa q

Pequeño tutorial cortesia de volta2016 para uso en terminales linux

CONFIGURACIÓN PROYECTO CON GIT

*Siempre al empezar un proyecto primero primero inspecciono los elementos :
ls
Luego cd Desktop – y me ubico en la carpeta del proyecto en la cual voy a trabajar
git —version
git config —global user.name “Volta”
git config —global user.email “[email protected]

$ git –version

                $ git config --global user.name "TU NOMBRE"

                $ git config --global user.email "TU CORREO DE GITHUB"

                $ git config --global --list

                $ git help [comando a buscar]

*Siempre al empezar un proyecto primero primero inspecciono los elementos :
ls
Luego cd Desktop – y me ubico en la carpeta del proyecto en la cual voy a trabajar
Una vez ubicado en el Desktop inspecciono la carpeta del proyecto
cd proyecto web

*clear es para ir borrando todo
git add -A
Primer commit git commit -m “archivos de proyecto instalados
Git log : me muestra Historial del proyecto con los datos del usuario

*Una vez comienzo a editar con el editor de texto puede ser “sublime o atom”
Aplico git status para ver que cambio hay, en que archivo y puedo comentar directamente
git commit–m “cambios de footer”
puedo preparar un archivo con git add “nombre del archivo
git commit “nombre del archivo” —amend

  1. git init -> crea el repositorio en local que es un directorio .git que contiene todo el historial
  2. git status ->para ver que esta en el repo y que no
  3. git add [archivos] -> stagin area, preparar lo que sera el commit
  4. git add –A ->alista todos los archivos para el commit (agrega todos los archivos de golpe)
  5. git commit–m «que es estecommit» -> crea el commit y queda agregado al historial del repo

Git y git hub
cd para llamar la carpeta
Ls para ver la lista
Git ini para comenzar

  • git help te muestra como funciona los parapeto es un parámetro
  • git help commit

git config –list para revisar listado
git help add commit

  1. git init –> crea el repositorio en local que es un directorio .git que contiene todo el historial
  2. git status ->para ver que esta en el repo y que no
  3. git add [archivos] -> stagin area, preparar lo que sera el commit
  4. git add -A ->alista todos los archivos para el commit
  5. git commit–m «que es estecommit» -> crea el commit y queda agregado al historial del repo

*git status te muestra en rojo los cambios del código en el html

git status te muestra que archivos puedes ir guardando
git add -A lista todo los archivos
git log
git superlog

RAMAS
git commit -am “commit nuevo” rama experimental

BORRAR
git reset borra todo el proyecto
git reset —hard “mas el ID del commit de ahi hacia arriba borra todo, si borro de arriba hacia bajo vuelve a los commit anteriores, si borro de abajo hacia arriba borra todo ejemplo ultimo de ID “
git add -A guardar
git commit -m “123”
git log

git reset mix recopila todos recopilo todos los commit y el e iguala el repositorio con el standing area
Y en vez de tener 3 commit creado recopila todo en 1

git reset soft hace cambio solo en repositorio pero iguala el standing con el working siempre se trabaja con el commit base git rest commit directamente el mix hay preparar los archivos para los commit en soft están todos los archivos preparados para el comino

git checkout viaja en ele tiempo pegas el commit ID

[email protected]
git init crear nuestro primer repositorio

git add subir uno a uno al work staging area git add – nombre del archivo

CUANDO REALIZO CAMBIOS en el html
git status

Giovannis-MBP:platzigit-master volta$ git status
On branch master
Changes not staged for commit:
(use "git add …" to update what will be committed)
(use "git checkout -- …" to discard changes in working directory)
modified:   index.html
no changes added to commit (use "git add" and/or "git commit -a")
Giovannis-MBP:platzigit-master volta$

Al cambio del index.html realizado o pagina x .html debemos agregar los siguientes después de darle git status
para integración básica
git add index.html
git commit -m “cambios Nombre y descripción”

git log ” te permite ver el nombre del la carpeta del proyecto el autor la fecha de commit y más
Variantes de comando de git log
git log — online te muestra el “sin detalles el commit id con el titulo”
git log — decorate “te muestra en que punto estas con head”
git log —online —graph
git log —stat “numero de linea que se editaron, cuales fueron los cambios a nivel de archivo”
git log -p “muestra los cambios y cuales fueron los cambios a nivel de código”
git shortlog “puedes ver en que esta trabajando cada desarrollador muestra los commit”
git log —prety=format

log –graph –abbrev-commit –decorate –date=relative –format=format:’%C(bold blue)%h%C(reset) – %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)’ –all

GIT HUB AVANZADO

cd Desktop , luego ls , cd platzigit-master, ls vemos los archivos .

git config —global alias.superlog
git status
git add -A , agregar todos los archivos
git commit -m “0” agrega todos los archivos

git log para ver los commit
git super log
git checkout -b experimental – “ para crear ramas y entrar en ellas “

PARA AGREGAR COMMIT
Iteración básica es para agregar archivos
archivo 1.txt
git add -A
git commit -m “1”

archivo 2.txt
git add -A
git commit -m “2”

archivo 3.txt
git add -A
git commit -m “3”

RAMAS
para crear una rama
1-.git checkout -b “experimental”

git branch “nombre de la rama”

git log para ver las commit ramas y features del master

HEAD ES LA ubicación donde uno esta programando.

Git merge

Para fusionar ramas
git merge experimental

Va a fusionar la rama experimental pero quiero que le coloques un nombre
PULSAR LA TECLA O , UNA VEZ COLOCAS EL NOMBRE ESC :X QUE ES CERRAR Y GUARDAR

PARA VER COMMIT

Luego
git superlog
git log
para restificación de commit de estar seguro y que sea el ultimo
Git commit -am “descripción cambiada” —amend

BORRAR RAMAS

git branch -d experimental

Merge crea un nuevo commit con los cambios de las ramas que estás fusionando.

Rebase se «trae» los cambios de la otra rama (Master) y los fusiona con los suyos.

git branch “para ver las ramas”

FUSIÓN

solucionar el conflicto , con git status vemos el archivo en rojo luego esta en rojo apene hay que subirlo a
Luego git add -A
Git status
Git commit -m “Fusión realizada”

REINICIAR PROYECTO

Entrar a las carpetas ocultas ls -la
La git guarda el proyecto en una carpeta y el registro lo tiene una carpeta llamada .git
Con el siguiente comando puedes eliminarla: rm – rf
ls -la para ver todo el repositorio

git checkout master es para volver atrás de un cambio en alguna rama

git merge “para la fusión” decidir con que titulo queda o modificación
Despues comentas interacción básica fusión ejecutada

se puede hacer un reset –hard
al inicio del proyecto o commit inicial sin tener el id del commit de esta forma:
git fetch origin
git reset –hard origin/master

REBASE

En las fusiones se crea un solo commit
En rebase pasa esto : a-b se colocan antes del commit de master
Por ejemplo si vuelvo mi ejemplo a git checkout master vuelven deprecar los commit de la rama del rebase a – b vuelves atrás “por que master esta en el commit con nombre cuarto” como subirlo:
git merge rama rebase

Ramarebase va acompañado de merge se va atacando de varias formas , cuando trabajas con rebase tienen que hacer “merge” git merge rama rebase
Crear ramas git checkout -b “nombre de la rama”

PARA CLONAR

cd ubico Desktop
git clone y el link en HTTPS. https://github.com/github/gemoji.git

LLAVE SSH RSA COMO ALGORITMO

$ ssh-keygen -t rsa -b 4096 -C «[email de GitHub]»

            Dar enter. Aceptar la localización por defecto.

            Contraseña.

            $ cd  ~/.ssh

            $ cat id_rsa.pub

            Copiamos la llave y la pegamos en Settings > SSH, dentro de GitHub.

Resumen

ssh-keygen -t rsa -b 4096 -C «poner aquí correo electrónico»

cat id_rsa.pub

Pegas el código y vuelvo al escritorio

WORK GITHUB
Creo la carpeta mkdri nombre carpeta
Entro a la carpeta con cd
git init
Agrego el primer archivo: touch 1.txt
git remote add origin “nombre del repositorio remoto

git push origin master
Para retomar proyecto
*desarrollamos
git fetch origin “refresh actualization del remoto”
git merge origin/master
git push origin master

Cued realizas fetch no cae en la rama master “ la local “ si no cae en origin master rama escondida
Luego de placa una fusión : git merge origin/master

PROCESO DE REPOSITORIOS “FORKED”
Pasos en orden

Crear ó entrar a la carpeta del proyecto cd
git init

    git remote add origin [HTTPS ó SSH del proyecto forked]
git remote add upstream [HTTPS ó SSH del proyecto principal]
git fetch upstream
git merge origin/upstream   “como conectamos la rama del repositorio original”
git fetch origin
git merge origin/master
Hacer cambios en local
git fetch upstream.            “Ramas escondidas “
git merge origin/upstream
git push origin master

http://git.miguelnieva.com/#/273

TESTING
Travis-ci.org
https://trello.com/b/EceUgtCL/ghost-roadmap

Extensión inalámbrica casera para el timbre de casa


Pensemos en personas de cierta edad  o simplemente personas que normalmente hacen su vida en alguna habitación de su vivienda que esta alejadas donde se encuentra el timbre de la puerta de acceso de la vivienda

Por ejemplo pensemos también que   esas personas están escuchando a un volumen alto la radio, su reproductor musical o simplemente están viendo la TV a un volumen alto y  suena el timbre de casa: en algunos casos , por no decir en la mayoría de los ocasiones evidentemente no lo van a oír, por lo que se hace necesario de algún modo sencillo  extender el sonido  del timbre de la cocina hasta otra sala sin necesidad de cables por ejemplo con un emisor inalámbrico dentro del timbre de la casa y un receptor-timbre  auxiliar para situarlo  donde más la convenga.

Además, por cierto, esta solución emisor-receptor  inalámbrica que vamos a proponer también es aplicable a los  timbres de los porteros automáticos con llamada zumbador convencionales de entrada a la vivienda compartiendo el receptor   variando únicamente la conexión del transmisor que deberá ser diferente, básicamente porque las  tensiones de disparo son muy diferentes   (220v de los timbre de la casa  frente   a los 8v a 24v de los porteros  automáticos ).   Precisamente esta solución  permite por ejemplo usar  melodías diferentes para  diferenciar  una llamada  de otro  en un mismo receptor, pero cuidado porque esta solución en caso de querer implementarla en un portero automático, NO servirá para sistemas con llamada electrónica aunque si funcionara perfectamente en porteros automáticos con llamada por zumbador si sustituimos la fuente de 220v 5vDC por un sencillo puente de diodos de 24V y un regulador 7805.

Uso en Timbre del Hogar

El conjunto transmisor y timbre inalámbrico se adaptan a la perfección a su cometido de conseguir que el timbre del portero electrónico con llamada por zumbador o el timbre de la vivienda se oigan donde sea necesario (por ejemplo en el comedor, en la terraza, en el dormitorio, etc.).

Observe  que vamos a adaptar  un circuito comercial para una finalidad concreta ( un timbre de casa inalámbrico) para conectarlo al timbre de acceso a nuestra vivienda y por tanto que se alimenta de la red de c.a.  de 220V por lo que debe extremar las precauciones

Como base vamos a usar un modulo recptor/emisor de buena relacion calidad precio modelo Electra Line 59199 de Timbre inalámbrico Timbre de Puerta, con Enchufe 10 A, 36 melodías Ajustable, Blanco que podemos comprar por unos 14€

Estas son algunas de las características:

  • Wireless.
  • Con el enchufe 10A.
  • 36 melodías ajustables.
  • 80 metros de alcance.
  • Incluyendo las baterías.

En el caso de necesitar extender el timbre de la vivienda vamos a necesitar reducir la tensión del timbre 220V AC en unos 5V DC para hacer funcionar el transmisor, el cual esta alimentado en origen con una pila compacta de 12V.

Obviamente al alimentar el emisor no basta para activar la señal que envía el transmisor, por lo que para que al alimentarlo envíe dicha señal, cortocircuitaremos los contactos del pulsador para que se ponga el trasmisor inmediatamente a enviar la señal de llamada en cuanto este alimentado el circuito emisor.

Empezaremos desmontado cualquier fuente conmutada de 220V/ 5V de las usadas para los cargadores USB dado que prescindiremos del enchufe al ir conectado estos hilos en paralelo con las conexiones del timbre, por lo que precisamente soldaremos un para de hilos justo en esas dos conexiones ( donde harían contacto los extremos del enchufe de AC)

Seguidamente dejaremos el capuchón frontal para proteger la electrónica, y cubriremos por ejemplo con cinta americana el lado opuesto de la placa para evitar cualquier contacto accidental con este

Ahora toca modificar el emisor para alimentarlo directamente con la fuente que hemos preparado soldando directamente los dos hilos de salida de 5v DC a los correspondientes del emisor ( cuidado no confundir los hilos pues quemaríamos el circuito)

Como toque interesante para ayudar la descarga de la fuente una vez haya dejado de pulsarse el timbre, podemos conectar una carga de 4 leds rojos en serie para intentar cortar el transmisor en cuanto se haya dejado de alimentar este

Otro aspecto a destacar, son los hilos del pulsador que deberemos cortocircuitar para activar la emisión ( hilos blanco y naranja en la imagen).

Solo nos queda colocar ambos componentes en el interior del timbre de la forma mas compacta posible , eso si aislando muy bien ambos componentes por ejemplo con cinta americana

Y una vez ubicadas ambas partes en el interior del timbre solo queda conectar los hilos de la fuente en paralelo con las conexiones AC del timbre ( mucho cuidado con los contactos accidentales pues podemos tener prsente uan fase aunque no se haya pulsado el timbre )

Finalmente un opción si no hay demasiado espacio es ubicar la fuente en el interior del timbre y el emisor fuera en un lateral

Uso en un portero automático

Vamos a describir para usar esta misma idea en un portero automático con llamada por zumbador, En efecto conseguiremos tener un segundo tono de llamada por ejemplo en un Urmet 1130. Sólo necesitamos desoldar la batería y el switch que se pasara por alto cortocircuitamos sus terminales como hemos hecho en la solución anteior.

En la imagen vemos el pequeño emisor que introduciremos en el telefonillo o en el propio timbre .  En este caso, los cables negro y azul se conectarán en paralelo con el timbre mecánico.  El cable blanco es para la antena emisora  que lógicamente, no se conecta a ningún sitio.

Respecto al resto de la electrónica montaremos un puente de diodos de 24V AC y 12DC, un pequeño regulador de tensión ( por ejemplo un 7805) a la salida DC del puente .

Instalar W11 y no morir en el intento


Cuando se anunció Windows 11 por primera vez, Microsoft lanzó los nuevos requisitos del sistema del sistema operativo , que incluían un procesador de seguridad TPM 2.0 , arranque seguro, CPU’s de las más modernas y al menos 64 GB de espacio en el disco duro, es decir , mas en detalle:

  • Procesador: 2 o más núcleos de 1 GHz o más, y tiene que ser un procesador de 64 bits compatible o sistema en un chip (SoC).
  • Memoria RAM: mínimo de 4 GB de memoria RAM.
  • Almacenamiento: mínimo de 64 GB de espacio libre en el disco duro donde vayas a instalarlo.
  • Firmware del sistema: un ordenador con UEFI, y compatible con Secure Boot.
  • TPM: compatibilidad con el Módulo de plataforma segura 2.0 o TPM 2.0, que desde 2016 es obligatorio para el hardware de cualquier ordenador con Windows. Te hemos escrito cómo comprobar si tienes chip TPM en el ordenador, ya que será el requisito más duro de cumplir.
  • Tarjeta gráfica: su tarjeta gráfica necesita ser compatible con DirectX 12 o posterior, y con el controlador WDDM 2.0.
  • Pantalla: una pantalla de un mínimo de 9 pulgadas en diagonal, con 720p de alta definición, y canal de 8 bits por color.
  • Otros: necesitará tener una cuenta de Microsoft, y necesitará estar conectado a Internet para la configuración inicial y cualquier actualización.
  • Un identificador válido (antiguo Cd-key) de Windows 10.

Cuando Microsoft se dio cuenta de que muchas personas, especialmente las de la empresa, estarían probando versiones preliminares de Windows 11 en máquinas virtuales, las eximieron de los requisitos del sistema

Windows 11: Microsoft está investigando estos ocho problemasSin embargo, Microsoft ahora requiere hardware compatible incluso en máquinas virtuales y adopta una postura firme sobre los requisitos del sistema, llegando incluso a decir que las personas que instalan Windows 11 en hardware incompatible pueden no obtener actualizaciones de seguridad .

Para aquellos que estén dispuestos a correr el riesgo de ejecutar Windows 11 en hardware incompatible, se ha creado un script que permite nuevas instalaciones y actualizaciones para eludir los requisitos del sistema operativo.

El script que omite los requisitos del sistema de Windows 11

Este nuevo script se lanzó como parte de la extremadamente útil envoltura Universal MediaCreationTool , un archivo por lotes que le permite crear una ISO para cualquier versión de Windows 10, con el soporte de Windows 11 agregado .

Universal MediaCreationTool por tanto da soporte ingenioso para ediciones comerciales, y ¡también es una herramienta de automatización de implementación de Windows 10/11 potente pero simple!, por lo que podemos instalar w10 y también w11 siempre obviamente que tengamos una licencia correcta de w10:

Envoltorio Universal MediaCreationTool
Envoltorio Universal MediaCreationTool
Fuente: BleepingComputer

Podemos configurar el funcionamiento del scripts a través de set vars, parámetros de línea de comandos o cambie el nombre del script como las iso 21H2 Pro MediaCreationTool.bat. Además contaremos con las opciones de configuración de Windows recomendadas con la menor cantidad de problemas en las actualizaciones configuradas a través de auto.cmd. Por cierto este script también cuenta con mensajes gráficos y es seleccionable por teclado la versión de destino y la acción preestablecida.

Estas son las opciones fundamentales:

Configuración automática con medios detectados sin confirmación: puede solucionar problemas de actualización que fallan agregando no_update al nombre de la secuencia de comandos
Crear ISO con los medios detectados en la C:\ESDcarpeta sin confirmación: puede anular los medios detectados agregando el nombre de la edición / idioma / arco al nombre de la secuencia de comandos
Crear USB con los medios detectados después de la confirmación

Y estas son algunas de las opciones posibles:

– Puede hacer clic en Atrás y seleccionar ISO lugar para guardar en un camino diferente preajustes personalizados por encima del soporte personalización medios ‘OEM’, que se pueden desactivar mediante la adición no_oema nombre del script
– Recogida $OEM$de carpetas (si existe) con ningún ajuste de configuración post como $OEM$\$$\Setup\Scripts\setupcomplete.cmd
– Escritura sources\PID.txtde archivos a preseleccionar la edición en el arranque multimedia o la configuración dentro de Windows (si está configurado)
– Escribir auto.cmdarchivo para volver a ejecutar la configuración automática bajo demanda, desde el medio (incluye Omitir TPM si las fuentes son 11)
– Escribir el winpeshl.iniarchivo en boot.wim para Omitir TPM Verificar en el arranque del medio (si las fuentes son 11)
Seleccionar en MCT con confirmación manual para todo en MCT GUI : sin personalización de medios ‘oem’, el script pasa la configuración de products.xml y se cierra sin tocar los medios

-Omitir la verificación de TPM en Dynamic Update v1 (basado en wmi) o v2 (basado en ifeo) scripts de alternancia independientes en MCT\dir : en todo el sistema, desbloquea las vistas previas internas en la actualización de Windows o ejecuta setup.exe manualmente mientras está en línea , al usar medios creados en otra PC por primera vez, se puede iniciar auto.cmd desde el medio una vez para habilitar

Si bien el script principal de este proyecto de código abierto es ‘ MediaCreationTool.bat ‘ que se utiliza para crear ISO de Windows, también incluye un script llamado ‘ Skip_TPM_Check_on_Dynamic_Update.cmd ‘, que configura el dispositivo para omitir las comprobaciones de hardware compatibles.

Cuando se ejecuta en un dispositivo Windows 10 o Windows 11, el script Skip_TPM_Check_on_Dynamic_Update.cmd realizará una variedad de tareas, que incluyen:

  • Cree el valor ‘ AllowUpgradesWithUnsupportedTPMOrCPU ‘ en la clave de registro HKEY_LOCAL_MACHINE \ SYSTEM \ Setup \ MoSetup y configúrelo en 1 .
  • Registra una suscripción de evento WMI denominada ‘Omitir comprobación de TPM en actualización dinámica’ que elimina el archivo ‘ C: \ $ WINDOWS. ~ BT \ appraiserres.dll ‘ cuando se inicia el ejecutable vdsldr.exe durante la instalación de Windows 11.Cabe señalar que la suscripción al evento WMI creada permanecerá vigente hasta que ejecute el script Skip_TPM_Check_on_Dynamic_Update.cmd nuevamente, lo que hará que se eliminen las suscripciones al evento. Puede hacer esto después de instalar o actualizar Windows 11.

Antes de usar este script, al intentar actualizar una máquina virtual de Windows 11 build 22449 a la última versión de vista previa, la actualización falló porque la instalación no podía ver la función de arranque seguro, un procesador TPM 2.0 y el disco del sistema era demasiado pequeño.

La configuración de Windows 11 falla en hardware incompatible
La configuración de Windows 11 falla en hardware incompatible
Fuente: BleepingComputer

Sin embargo, después de ejecutar este script, podríamos instalar la última versión preliminar 22463 de Windows 11 sin ningún problema.

Vista previa de Windows 11 build 22463 instalada en VirtualBox
Vista previa de Windows 11 build 22463 instalada en VirtualBox

Cualquiera que decida usar esta omisión debe tener en cuenta que este es un método no compatible para instalar Windows 11 y podría provocar problemas de rendimiento u otros errores al usar el sistema operativo. Además, es posible que Microsoft no proporcione actualizaciones de seguridad para dispositivos no compatibles, por lo que es probable que su instalación sea menos segura.

Resumimos ahora los pasos para poder realizar la instalación de w11 en un equipo que en principio no lo permitía:

  • Necesitamos un pen-drive de al menos 8GB y una cuenta gratuita de Microsoft ( por ejemplo una cuenta de correo de hotmail)
  • Descargaremos el script oficial desde su pagina de github mediante la opción de «Download Zip» desde el siguiente enlace https://gist.github.com/AveYo/c74dc774a8fb81a332b5d65613187b15#file-mediacreationtool-bat-md
  • Descomprimimos el contenido del fichero en una carpeta
  • Buscamos el fichero MediaCreationToool.cmd y ejecutamos ahora el citado script con permisos de administrador
  • Seleccionamos cuando nos lo solicite la unidad exacta donde hayamos enchufado el pen-drive ( por ejemplo D:\) ,la cual será la ubicación en la que crearemos la unidad de instalación
  • Seleccionamos la ultima opción («11») dado que las versiones superiores sirven para instala versiones de windows 10 siempre qeu se cuente con licencias para ello
  • Esperamos a que se complete el proceso en el que básicamente se descargara la imagen correcta , se instalaré ésta en el pen -drive y finalmente borrara los archivos temporales
  • Una vez completado el script ejecutaremos el script y nos haya devuelto el control , ejecutaremos DOS veces Skip_TPM_Check_on_Dynamic_Update
  • Apagamos el equipo y configuramos la BIOS para que arranque el PC desde una unidad USB .
  • Pinchamos la unidad USB que hemos creado y seguimos las instrucciones teniendo a mano la licencia de W10 pues nos la pedirá esta como primer paso para instalar W11)
  • !!SUERTE pues ya nos deberia dejar instalar Windows 11 aunque no cumplamos con todos los requisitos establecidos!!

No debemos olvidar que al parece Microsoft ha comentado  que estos ordenadores donde hayamos realizado el procedimiento anterior podrían tener más errores, y probablemente no recibirán tantas actualizaciones de seguridad del sistema operativo, así como tampoco las actualizaciones periódicas que vayan lanzando cada medio año o cada año con nuevas características, pero si contamos con un equipo algo antiguo que no va demasiado bien y queremos darle una oportunidad , quizás este sea un buen camino para darle una nueva vida.

Problemas al reconocer el puerto con el ESP8266



Node MCU
 es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  que pueden ademas  pueden   involucrar el IoT  .

Esta placa  destaca  porque integra capacidades de comunicación via WiFi , conteniendo en su interior  un microprocesador que puede ser programado fácilmente usando el  conocido lenguaje de programación Lua o bien vía Arduino IDE.

Obviamente ante todo no podemos perder de vista su bajisimo precio ( menos de 7.5€  ) comparados con otras opciones , pues no debemos olvidar  que incluye  el modulo wifi integrado  y un bus GPIO para conectar dispositivos de E/S.
Node MCU es una plataforma de desarrollo permite un prototipado rápido, para una vez satisfechos con el resultado, portar el desarrollo a un sistema final con un chip ESP8266 como pieza central.

A la hora de programar nuevas funciones, si optamos por utilizar Lua, dispondremos de un sistema simple con buena comunidad de usuarios. En cambio programar con el sistema Arduino nos aporta un fantástico IDE y un sinfin de manuales y ejemplos de desarrollo.

Este modulo es Ideal como una solución independiente en lugar de Arduino además de Wi-Fi  integrado siendo fácil de programar a través del IDE de Arduino (como vamos a ver ) , al igual que un Arduino.
Todos los periféricos con bus I2C puede unirse,por ejemplo Pantallas OLED, pantallas LCD, temperatura, presión, sensores de humedad pueden ser conectados en paralelo. También se puede conectar múltiples DS18B20

Sin embargo, sólo hay una entrada analógica y salida y las pantallas táctiles no se pueden conectar con ella.

Los pasos  a seguir   para conectar un ESP8266     son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino
esp
  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador.

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

  • Conecte  un cable usb  de datos al ESP8266
  • Seleccione   Herramientas –>ESP8266   y ahi la placa que haya comprado. En caso de  haberla comprado en Amazon aqui seleccione  NodeMCU 1.0 (ESP-12EModule).

node.png
  • En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el  puerto al que está conectado su ESP8266.En el ejemplo  es el COM11
puerto.png

Problemas al reconocer el puerto

En varios casos, la placa no se detecta debido a que faltan los controladores. Sin embargo, también puede ser por el puerto USB o el cable.

Si después de instalar los controladores sigue sin funcionar, por favor:

  • Verifique conectando la placa en otro puerto
  • Intente cambiar el cable USB de conexión por otro porque a veces aunque haya alimentación pueden fallar ( no olvidar que en un cable USB standard deberia haber 4 hilos)
  • Pruebae en otro ordenador distinta

Una vez dicho eso, veamos los controladores de NodeMCU 8266 en Windows.

Controladores para esp8266 en Windows

Hay que ir al siguiente enlace:

https://github.com/nodemcu/nodemcu-devkit/tree/master/Drivers

Y descargar el archivo que se llama CH341SER_WINDOWS.zip. Si quieres un enlace directo lo dejo aquí:

https://github.com/nodemcu/nodemcu-devkit/raw/master/Drivers/CH341SER_WINDOWS.zip

Una vez que lo descargues, extraer el fichero comprimido con extension .zip. Tendrá un programa llamado CH341SER.EXE, ejecútelo y dale permisos de administrador.

En la siguiente ventana haz click en Install:

Instalar drivers de NodeMCU 8266 en Windows

Espere a recibir la notificación de que se ha instalado y eso es todo. Debe detectar el dispositivo en un puerto COM; yo lo tenía en el COM4.

Conclusión

Es necesario mencionar que esto lo probé en Windows 10 de 64 bits usando PlatformIO dentro de Visual Studio Code, pero supongo que debe funcionar de igual modo en otras plataformas.

Lo explicado aquí está en un issue de GitHub.

scikit-learn: Guardar y restaurar modelos


En muchas ocasiones, mientras trabaja con la biblioteca scikit-learn , deberá guardar sus modelos de predicción en un archivo y luego restaurarlos para reutilizar su trabajo anterior para: probar su modelo con datos nuevos, comparar varios modelos o Algo más. Este procedimiento de guardado también se conoce como serialización de objetos: representa un objeto con un flujo de bytes para almacenarlo en el disco, enviarlo a través de una red o guardarlo en una base de datos, mientras que el procedimiento de restauración se conoce como deserialización. En este artículo, analizamos tres formas posibles de hacer esto en Python y scikit-learn, cada una presentada con sus pros y sus contras.

Herramientas para guardar y restaurar modelos

La primera herramienta que describimos es Pickle , la herramienta estándar de Python para la (des) serialización de objetos. Luego, miramos la biblioteca Joblib que ofrece (des) serialización fácil de objetos que contienen matrices de datos grandes, y finalmente presentamos un enfoque manual para guardar y restaurar objetos hacia / desde JSON (JavaScript Object Notation). Ninguno de estos enfoques representa una solución óptima, pero se debe elegir el ajuste correcto de acuerdo con las necesidades de su proyecto.

Inicialización del modelo

Inicialmente, creemos un modelo de scikit-learn. En nuestro ejemplo usaremos un modelo de regresión logística y el conjunto de datos Iris . 

Vamos a importar las bibliotecas necesarias, cargar los datos y dividirlos en conjuntos de prueba y entrenamiento.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load and split data
data = load_iris()
Xtrain, Xtest, Ytrain, Ytest = train_test_split(data.data, data.target, test_size=0.3, random_state=4)

Ahora creemos el modelo con algunos parámetros no predeterminados y ajustémoslo a los datos de entrenamiento. Suponemos que ha encontrado previamente los parámetros óptimos del modelo, es decir, los que producen la mayor precisión estimada.

# Create a model
model = LogisticRegression(C=0.1, 
                           max_iter=20, 
                           fit_intercept=True, 
                           n_jobs=3, 
                           solver='liblinear')
model.fit(Xtrain, Ytrain)

Y nuestro modelo resultante:

LogisticRegression(C=0.1, class_weight=None, dual=False, fit_intercept=True,
    intercept_scaling=1, max_iter=20, multi_class='ovr', n_jobs=3,
    penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
    verbose=0, warm_start=False)

Usando el fitmétodo, el modelo ha aprendido sus coeficientes que están almacenados en model.coef_. El objetivo es guardar los parámetros y los coeficientes del modelo en un archivo, por lo que no es necesario repetir el entrenamiento del modelo y los pasos de optimización de los parámetros nuevamente con datos nuevos.

Módulo pickle

En las siguientes líneas de código, el modelo que creamos en el paso anterior se guarda en un archivo y luego se carga como un nuevo objeto llamado pickled_model. A continuación, el modelo cargado se utiliza para calcular la puntuación de precisión y predecir los resultados sobre nuevos datos no vistos (de prueba).

import pickle

#
# Create your model here (same as above)
#

# Save to file in the current working directory
pkl_filename = "pickle_model.pkl"
with open(pkl_filename, 'wb') as file:
    pickle.dump(model, file)

# Load from file
with open(pkl_filename, 'rb') as file:
    pickle_model = pickle.load(file)
    
# Calculate the accuracy score and predict target values
score = pickle_model.score(Xtest, Ytest)
print("Test score: {0:.2f} %".format(100 * score))
Ypredict = pickle_model.predict(Xtest)

La ejecución de este código debería generar su puntuación y guardar el modelo a través de Pickle:

$ python save_model_pickle.py
Test score: 91.11 %

Lo mejor de usar Pickle para guardar y restaurar nuestros modelos de aprendizaje es que es rápido: puede hacerlo en dos líneas de código. Es útil si ha optimizado los parámetros del modelo en los datos de entrenamiento, por lo que no necesita repetir este paso nuevamente. De todos modos, no guarda los resultados de la prueba ni ningún dato. Aún así, puede hacer esto guardando una tupla, o una lista, de varios objetos (y recuerde qué objeto va a dónde), de la siguiente manera:

tuple_objects = (model, Xtrain, Ytrain, score)

# Save tuple
pickle.dump(tuple_objects, open("tuple_model.pkl", 'wb'))

# Restore tuple
pickled_model, pickled_Xtrain, pickled_Ytrain, pickled_score = pickle.load(open("tuple_model.pkl", 'rb'))

Módulo Joblib

La biblioteca Joblib está destinada a ser un reemplazo de Pickle, para objetos que contienen datos grandes. Repetiremos el procedimiento de guardar y restaurar como con Pickle.

from sklearn.externals import joblib

# Save to file in the current working directory
joblib_file = "joblib_model.pkl"
joblib.dump(model, joblib_file)

# Load from file
joblib_model = joblib.load(joblib_file)

# Calculate the accuracy and predictions
score = joblib_model.score(Xtest, Ytest)
print("Test score: {0:.2f} %".format(100 * score))
Ypredict = pickle_model.predict(Xtest)
$ python save_model_joblib.py
Test score: 91.11 %

Como se ve en el ejemplo, la biblioteca Joblib ofrece un flujo de trabajo un poco más simple en comparación con Pickle. Si bien Pickle requiere que se pase un objeto de archivo como argumento, Joblib funciona tanto con objetos de archivo como con nombres de archivo de cadena. En caso de que su modelo contenga grandes conjuntos de datos, cada conjunto se almacenará en un archivo separado, pero el procedimiento de guardar y restaurar seguirá siendo el mismo. Joblib también permite diferentes métodos de compresión, como ‘zlib’, ‘gzip’, ‘bz2’ y diferentes niveles de compresión.

Guardar y restaurar manualmente a JSON

Dependiendo de su proyecto, muchas veces encontrará Pickle y Joblib como soluciones inadecuadas. De todos modos, siempre que desee tener un control total sobre el proceso de guardar y restaurar, la mejor manera es crear sus propias funciones manualmente.

A continuación, se muestra un ejemplo de cómo guardar y restaurar objetos manualmente mediante JSON. Este enfoque nos permite seleccionar los datos que deben guardarse, como los parámetros del modelo, los coeficientes, los datos de entrenamiento y cualquier otra cosa que necesitemos.

Dado que queremos guardar todos estos datos en un solo objeto, una forma posible de hacerlo es crear una nueva clase que herede de la clase modelo, que en nuestro ejemplo es LogisticRegression. La nueva clase, llamada MyLogReg, implementa los métodos save_jsonload_json para guardar y restaurar a / desde un archivo JSON, respectivamente.

Para simplificar, guardaremos solo tres parámetros del modelo y los datos de entrenamiento. Algunos datos adicionales que podríamos almacenar con este enfoque son, por ejemplo, una puntuación de validación cruzada en el conjunto de entrenamiento, datos de prueba, puntuación de precisión en los datos de prueba, etc.

import json
import numpy as np

class MyLogReg(LogisticRegression):
    
    # Override the class constructor
    def __init__(self, C=1.0, solver='liblinear', max_iter=100, X_train=None, Y_train=None):
        LogisticRegression.__init__(self, C=C, solver=solver, max_iter=max_iter)
        self.X_train = X_train
        self.Y_train = Y_train
        
    # A method for saving object data to JSON file
    def save_json(self, filepath):
        dict_ = {}
        dict_['C'] = self.C
        dict_['max_iter'] = self.max_iter
        dict_['solver'] = self.solver
        dict_['X_train'] = self.X_train.tolist() if self.X_train is not None else 'None'
        dict_['Y_train'] = self.Y_train.tolist() if self.Y_train is not None else 'None'
        
        # Creat json and save to file
        json_txt = json.dumps(dict_, indent=4)
        with open(filepath, 'w') as file:
            file.write(json_txt)
    
    # A method for loading data from JSON file
    def load_json(self, filepath):
        with open(filepath, 'r') as file:
            dict_ = json.load(file)
            
        self.C = dict_['C']
        self.max_iter = dict_['max_iter']
        self.solver = dict_['solver']
        self.X_train = np.asarray(dict_['X_train']) if dict_['X_train'] != 'None' else None
        self.Y_train = np.asarray(dict_['Y_train']) if dict_['Y_train'] != 'None' else None
        

Ahora probemos la MyLogRegclase. Primero creamos un objeto mylogreg, le pasamos los datos de entrenamiento y lo guardamos en un archivo. Luego creamos un nuevo objeto json_mylogregy llamamos al métod load_json para cargar los datos del archivo.

filepath = "mylogreg.json"

# Create a model and train it
mylogreg = MyLogReg(X_train=Xtrain, Y_train=Ytrain)
mylogreg.save_json(filepath)

# Create a new object and load its data from JSON file
json_mylogreg = MyLogReg()
json_mylogreg.load_json(filepath)
json_mylogreg

Al imprimir el nuevo objeto, podemos ver nuestros parámetros y datos de entrenamiento según sea necesario.

MyLogReg(C=1.0,
     X_train=array([[ 4.3,  3. ,  1.1,  0.1],
       [ 5.7,  4.4,  1.5,  0.4],
       ...,
       [ 7.2,  3. ,  5.8,  1.6],
       [ 7.7,  2.8,  6.7,  2. ]]),
     Y_train=array([0, 0, ..., 2, 2]), class_weight=None, dual=False,
     fit_intercept=True, intercept_scaling=1, max_iter=100,
     multi_class='ovr', n_jobs=1, penalty='l2', random_state=None,
     solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

Dado que la serialización de datos usando JSON realmente guarda el objeto en un formato de cadena, en lugar de un flujo de bytes, el archivo ‘mylogreg.json’ podría abrirse y modificarse con un editor de texto. Aunque este enfoque sería conveniente para el desarrollador, es menos seguro ya que un intruso puede ver y modificar el contenido del archivo JSON. Además, este enfoque es más adecuado para objetos con una pequeña cantidad de variables de instancia, como los modelos scikit-learn, porque cualquier adición de nuevas variables requiere cambios en los métodos de guardar y restaurar.

Problemas de compatibilidad

Si bien algunos de los pros y los contras de cada herramienta se cubrieron en el texto hasta ahora, probablemente el mayor inconveniente de las herramientas Pickle y Joblib es su compatibilidad con diferentes modelos y versiones de Python.

Compatibilidad con la versión de Python : la documentación de ambas herramientas indica que no se recomienda (des) serializar objetos en diferentes versiones de Python, aunque podría funcionar con cambios menores de versión.

Compatibilidad del modelo : uno de los errores más frecuentes es guardar su modelo con Pickle o Joblib y luego cambiar el modelo antes de intentar restaurar desde un archivo. La estructura interna del modelo debe permanecer sin cambios entre guardar y recargar.

Un último problema con Pickle y Joblib está relacionado con la seguridad. Ambas herramientas pueden contener código malicioso, por lo que no se recomienda restaurar datos de fuentes no confiables o no autenticadas.

Conclusiones

En esta publicación describimos tres herramientas para guardar y restaurar modelos de scikit-learn. Las bibliotecas Pickle y Joblib son rápidas y fáciles de usar, pero tienen problemas de compatibilidad en diferentes versiones de Python y cambios en el modelo de aprendizaje. Por otro lado, el enfoque manual es más difícil de implementar y debe modificarse con cualquier cambio en la estructura del modelo, pero en el lado positivo podría adaptarse fácilmente a varias necesidades y no tiene problemas de compatibilidad.