?

Log in

No account? Create an account

Network Analysis Using Wireshark Cookbook

Wireshark es, definitivamente, el estándar del mercado para el análisis de redes y el análisis de redes TCP/IP en particular y es muy popular para solución de problemas y para entender lo que realmente está sucediendo a través de la red y cuáles son los problemas que pueden existir.






Network Analysis Using Wireshark Cookbook de Yoram Orzach
Paperback: 452 pages
Publisher: Packt Publishing (December 24, 2013)
Language: English
ISBN-10: 1849517649
ISBN-13: 978-1849517645




Como señalé en post anterior sobre libros por mi trabajo he tenido que leer muchos libros, uno de ellos es el libro Network Analysis Using Wireshark Cookbook de Yoram Orzach, un fantástico libro de cocina que, como tal, es una referencia rápida y muy práctica para trabajar con Wireshark en todo tipo de redes. Sin embargo, tiene algo que lo hace diferente de otros libros de cocina, además de indicar el problema específico  como trabajarlo con Wireshark proporciona los fundamentos teóricos, con el fin de dar al lector los antecedentes teóricos requeridos.
El contenido pasa por una buena introducción de las funciones básicas de Wireshark, filtros, display filters, herramientas básicas y avanzadas de estadística, Ethernet, LAN Switching, and Wireless LAN, análisis ARP y IP, análisis de tráfico TCP/UDP, HTTP, DNS, troubleshoting, multimedia y un apartado sobre seguridad en redes que está muy interesante.
En resumen, este ha sido uno de los libros más utiles sobre redes que he podido leer en este último tiempo.
 

Tags:

La bici es el mejor invento del mundo, siempre he pensado que los ecologistas están cambiando la contaminación atmosférica por la contaminación del agua, pues las baterías eléctricas y otros materiales de estos vehículos eléctricos solo provocarán una transformación en las futuras preocupaciones ambientales.


En cualquier discusión sobre la seguridad cibernética industrial, siempre va a haber objeciones de algunas personas que se basan en percepciones erróneas. Las más comunes son:

  1. La ciberseguridad de las redes industriales no es necesaria. Este mito proviene de la creencia de que cualquier cosa que suceda en IT no aplica para OT. Esto simplemente no es cierto. Si bien la segmentación de redes es un método valioso para establecer zonas de seguridad y mejorar la seguridad, la separación absoluta de las redes es prácticamente imposible de obtener. Siempre existen sistemas que admiten puertos de diagnóstico inalámbricos, medios extraíbles que se pueden operar manualmente, etc. Este mito también supone que todas las amenazas se originan fuera de la red industrial, y no aborda el riesgo de la información privilegiada y el impacto resultante de un evento cibernético en el ICS de un usuario autorizado.

  2. La seguridad industrial es imposibile. La seguridad requiere parches. Los dispositivos deben ser parcheados para protegerlos contra la explotación de una vulnerabilidad descubierta, y los sistemas antivirus necesitan actualizaciones regulares. Los entornos de control no pueden soportar ciclos de parches adecuados, lo que hace que las medidas de seguridad cibernética sean discutibles. Si bien es cierto que se trata de desafíos a los que se enfrentan los ICS, no significa que una postura de seguridad fuerte no se puede obtener a través de otros controles compensadores. La seguridad industrial requiere una base de gestión de riesgos y una comprensión del ciclo de vida de la seguridad.

  3. La seguridad cibernética es responsabilidad de otra persona. Este es muy típico en muchas empresas, sobre todo cuando no se establecen las políticas de responsabilidades adecuadas, el paso de la pelota cuando hay dificultades el lo primero que suelen hacer. Los gerentes operativos de la planta esperan que los gerentes de TI adopten la responsabilidad (y el presupuesto) para la seguridad cibernética o biceversa. La Ciberseguridad debe estar considerada en los niveles ejecutivos más altos en una organización debidamente estructurada, y las responsabilidades apropiadas se reducirán tanto a TI como a OT según sea necesario, para que puedan trabajar en conjunto, la seguridad cibernética es un problema integral que requiere una solución integral.

  4. Es lo mismo que la seguridad cibernética "IT". Esta es otra percepción errónea común que a veces puede dividir los grupos de operaciones de TI y planta dentro de una organización. El solo hecho de que las redes OT tangan el mismo ethernet no significa que la ciberseguridad deba ser tratada de la misma manera. Como señalé en una conferencia de INACAP este año, los protocolos SCADA/ICS tienen particularidades especiales que no permiten que el mismo firewall y el mismo IDS/IPS funcionen adecuadamente en ambos ambientes. Las redes industriales y empresariales son diferentes, y requieren diferentes medidas de seguridad para protegerlas adecuadamente.

Modo twitter

Inauguraré el modo twitter, es decir, publicaré lo que pienso como si fuera twitter, asi le doy un uso mas intensivo a la app de Livejournal, por otra parte, a veces he usado LinkedIn en ese modo, pero cuando uno busca empleo no es muy buena idea.
Pensaba abrir una cuenta en twitter, pero como esa red es un gallinero, me da lata crear una cuenta y publicar.
Todas las publicaciones con hashtag twitter quedaran públicas solo para los que estan como amigos en Livejournal.

Tags:

pyplot en Julia

Por estos días estuve pegado en un roblema de plot en Julialang utiizando la librería pyplot de python, anteriormente trabajé con otra librería de ploting, pero ahora estoy leyendo el libro Statistics With Julia [DRAFT] de Hayden Klok, Yoni Nazarathy.
El libro está increible, pero tiene algunos problemas, pues seguramente cuando lo escribieron aún utilizaban una versión anterior de pyplot y que ahora hay algunas sentencias deprecadas.
La Actividad 10 “Listing 1.10: Histogram of hailstone sequence lengthsme arrojaba el siguiente error:

┌ Warning: `getindex(o::PyObject, s::Symbol)` is deprecated in favor of dot overloading (`getproperty`) so elements should now be accessed as e.g. `o.s` instead of `o[:s]`.
│   caller = top-level scope at none:0
└ @ Core none:0

Erroneamente yo buscaba el problema en la linea 3, pero no, gracias a la ayuda de kristoffer.carlsson en el foro de Julia, al código comenzó a funcionar, pero la corrección se debía hacer en 18 (Thanks Kriss).

Aquí el código:

using PyPlot

function hailLength(x::Int)
   n=0
    while x != 1
        if x % 2 == 0
           x = Int(x/2)
        else
           x = 3x +1
        end
           n += 1
    end
    return n
end

lengths = [hailLength(x0) for x0 in 2:10^7]
plt[:hist](lengths, 1000, normed="true") #deprecated code
plt.hist(lengths, 1000, density="true")
xlabel("Length")
ylabel("Frequency");

Ahora, lo curioso es que el código funciona en la consola REPL, pero en VS Code no funciona, no se por qué, eso lo tengo que averiguar mañana, porque ya es muy tarde hoy.

REPL
julia> using PyPlot

julia> function hailLength(x::Int)
          n=0
          while x != 1
              if x % 2 == 0
                  x = Int(x/2)
              else
                  x = 3x +1
              end
                  n += 1
          end
          return n
      end
hailLength (generic function with 1 method)

julia> lengths = [hailLength(x0) for x0 in 2:10^7]
9999999-element Array{Int64,1}:
  1
  7
  2
  5
  8
16
  3
19
  6
14
  
114
114
114
114
163
163
163
220
145

julia> plt.hist(lengths, 1000, density="true")
([1.46199e-7, 1.46199e-7, 1.46199e-7, 0.0, 1.46199e-7, 2.92398e-7, 0.0, 2.92398e-7, 5.84795e-7, 0.0  …  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.46199e-7], [1.0, 1.684, 2.368, 3.052, 3.736, 4.42, 5.104, 5.788, 6.472, 7.156  …  678.844, 679.528, 680.212, 680.896, 681.58, 682.264, 682.948, 683.632, 684.316, 685.0], PyCall.PyObject[PyObject <matplotlib.patches.Rectangle object at 0x13d954a90>, PyObject <matplotlib.patches.Rectangle object at 0x124e74668>, PyObject <matplotlib.patches.Rectangle object at 0x13d954d68>, PyObject <matplotlib.patches.Rectangle object at 0x13d960400>, PyObject <matplotlib.patches.Rectangle object at 0x13d960748>, PyObject <matplotlib.patches.Rectangle object at 0x13d960a90>, PyObject <matplotlib.patches.Rectangle object at 0x13d960dd8>, PyObject <matplotlib.patches.Rectangle object at 0x13d960ef0>, PyObject <matplotlib.patches.Rectangle object at 0x13d96b4a8>, PyObject <matplotlib.patches.Rectangle object at 0x13d96b7f0>  …  PyObject <matplotlib.patches.Rectangle object at 0x14737ddd8>, PyObject <matplotlib.patches.Rectangle object at 0x14737def0>, PyObject <matplotlib.patches.Rectangle object at 0x1473884a8>, PyObject <matplotlib.patches.Rectangle object at 0x1473887f0>, PyObject <matplotlib.patches.Rectangle object at 0x147388b38>, PyObject <matplotlib.patches.Rectangle object at 0x147388e80>, PyObject <matplotlib.patches.Rectangle object at 0x147388f98>, PyObject <matplotlib.patches.Rectangle object at 0x147392550>, PyObject <matplotlib.patches.Rectangle object at 0x147392898>, PyObject <matplotlib.patches.Rectangle object at 0x147392be0>])

julia> xlabel("Length")
PyObject Text(0.5, 23.52222222222222, 'Length')

julia> ylabel("Frequency");

julia>

OpenSSL Cookbook

Como mencioné en post anterior, últimamente he leído mucha literatura técnica, dejando de lado otros libros por el momento. Uno de los libros técnico que he leído también es el libro titulado “OpenSSL Cookbook. A Guide to the Most Frequently Used OpenSSL Features and Commands” de Ivan Ristić.

OpenSSL Cookbook
by Ivan Ristić
Version 1.1, published in October 2013.
Copyright © 2013 Feisty Duck Limited. All rights reserved.
First published in May 2013. ISBN: 978-1907117053

Debo declarar que los libros de cocina son uno de mis favoritos, pues son libros que van inmediatamente a la práctica y no se pierden en los conceptos teórico que muchas veces entorpecen la lectura o no son lo que uno esperaría en terminos de práctica, pero cuidado, los libros de cocina no son adecuados para todos. Como señalé, los libros de cocina van inmediatamente a la práctica y no profundizan en la parte teórica, esto es muy adecuado para los que ya han pasado por una carrera de ciencias de la computación o similar, que haya tenido un fuerte componente teórico; eso también hay que aclararlo, porque muchas universidades hoy, en cuanto a redes, siguen lo que dictamina CCNA de Cisco y de verdad es muy práctico, pero pobre en fundamentos. Sin embargo, si ya se tiene un conocimiento teórico sólido respecto de la materia, los libros de cocina vienen a complementar muy bien la práctica necesaria del arte.
En particular, el libro mencionado es una guía completa para el uso seguro de SSL/TLS y PKI en la implementación de infraestructura y el desarrollo de aplicaciones web, comenzando con un punto común de partida y comandos básicos, para luego avanzar en la administración de llaves y certificados, la correcta configuración de estos y las mejores prácticas de entrega y despliegue, configuración, performance etc. Sin embargo, también tiene alguna deficiencias derivadas del inexorable paso del tiempo, desde su publicación en 2013 ha “pasado mucha agua bajo el puente” y ya está obsoleto respecto de los cuidados que hay que tener para los últimos y más graves ataques contra el protocolo SSL y su muerte definitiva, en pro de TLS, como son Heartbleed, POODLEAttack, Shellshock, FREAKy SSL DROWN, Ivan Ristić publicó un libro posterior a este, pero desconozco su contenido, ya tendré la oportunidad de comprarlo. Otro punto débil que encontré en el libro es que da muy buenas recomendaciones para el hardening de SSL/TLS, sin embargo, no profundiza en la aplicación de las recomendaciones a nivel de Apache o similar.
En definitiva, sí, este es un buen libro, pero como suele suceder, siempre hay que investigar más.
¡Shut up, and hack...!

Tags:

Street Photography – For the Purist

Ocasionalmente leo libros sobre fotografía, y sobre fotografía de calle particularmente. Street Photography – For the Purist de Chris Weeks es el último que he leído. El libro lo pueden encontrar aquí y encontré el Vimeo del autor aquí.
Con la colaboración fotográfica y de testimonios de:

  • Severin Koller – Austria


  • Matthew Craig – United States of America

  • Deborah Delasio – Italy


  • Darren Abate – United States of America

  • Bernhard Wolf – Austria

  • Michael Kaiser – Germany

  • Rainer Pawellek – France

  • Errol Lyons-Rainey – United Kingdom

  • Massimiliano Mortillaro – Czech Republic

  • Patrick Kahn – Los Angeles/Paris

Algunos de ellos los busqué en internet a partir de las direcciones web que proporciona el autor, muchos de ellos apuntaban a blogs que ya están abandonados, de hecho uno de ellos hablaba de que los tiempos han cambiado y por eso abandonaba su blog, me llamó la atención, pues yo persisto en escribir aquí después de muchos años.
En general el libro está compuesto por tomas y testimonios de lo que es la fotografía de calle, su propia experiencia y recomendaciones para realizar esta actividad.
Las fotografía están muy buenas, sin embargo, lo que relatan es muy estilo del “yo soy el mejor, los otros que se jodan” de hecho usan un lenguaje por el cual, a mi parecer, quieren hacerse entender como rebeldes y que nada más les importa, y abundan las palabras com “putos”, “que se jodan”, “que se pudran”, “maldita sea” y etc.
Por otra parte, son unos fans boy de Leica y la fotografía en blanco y negro, sin duda, Leica es una muy buena cámara, pero por favor, ¡despreciar el resto de cámaras!…, tal vez digan lo mismo de mi preferencia por Pentax y Ricoh, aunque ahora disparo con un teléfono Huawei y anterior con un iPhone 5s, pero bueno, es cuestión de preferencias.
Los consejos que dan sí, son muy buenos, muy parecidos a los que se dan en otros libros, pero en este caso están mejor explicados que en otras publicaciones que he leído.
Lo bueno. Los datos de fotógrafos clásicos, que yo no conozco ninguno, me pusieron a trabajar en esto para saber mas, seguramente son nombres que ya mencionaron en otro libro, pero soy pésimo recordando nombres.
En fin, es un buen libro, pero la pseudo rebeldía pienso que no es necesaria para enseñar su buen trabajo.

Si hay algo que me gusta de la ciencia es esa capacidad de exigirse a si misma como método para encontrar la verdad.
En esta publicacion de Maurizio Ferrari y Paolo Cremonesi del Politecnico di Milano junto a Dietmar Janach de la University of Klagenfurt ponen a prueba investigaciones previas respecto de algoritmos neuronales de recomendaciones top-n.

Siempre poner a prueba o cuestionar una investigacion previa es un tema espinudo, pero su conclusión la comparto, los resultados de una investigacion deben ser reproducibles y siempre es deseable que se entreguen las herramientas que faciliten la comprobación y posteriores trabajos, ellos mismos en esta publicación comparten los resultados y el codigo fuente.
Ya, Shut up and hack slackers!!!...

¿Estamos realmente haciendo mucho progreso? Un inquietante análisis de los recientes enfoques de recomendación neuronal

Técnicas de aprendizaje profundo se han convertido en el método de elección para los investigadores que trabajan en los aspectos algorítmicos de sistemas de recomendación. Con el interés creciente fuertemente en el aprendizaje de máquina en general, en consecuencia, resulta difícil hacer un seguimiento de lo que representa el estado del arte en el momento, por ejemplo, para las tareas de recomendación de top-n. Al mismo tiempo, varias publicaciones recientes señalan problemas en la práctica de la investigación de hoy en el aprendizaje de la máquina aplicada, por ejemplo, en cuanto a la reproducibilidad de los resultados o la elección de las líneas de base al proponer nuevos modelos. En este trabajo se presenta los resultados de un análisis sistemático de propuestas algorítmicas para las tareas de recomendación de top-n. Específicamente, se consideraron los 18 algoritmos que se presentaron en conferencias de investigación de alto nivel en los últimos años. Sólo 7 de ellos se podría reproducir con un esfuerzo razonable. De estos métodos, sin embargo resultó que 6 de ellos a menudo puede ser superado con métodos heurísticos simples comparable, por ejemplo, basados en técnicas basadas en gráfico o más cercano vecino. El restante claramente superó a las líneas de base, pero no superan constantemente un método de clasificación lineal no neural bien afinado. En general, nuestro trabajo arroja luz sobre una serie de posibles problemas en beca de aprendizaje de máquina de hoy y pide mejora de las prácticas científica en esta área. Código fuente de nuestros experimentos y resultados completos están disponibles en: esta dirección de URL de https.

publicacion aqui: https://arxiv.org/abs/1907.06902v1

Por mi trabajo este año me ha tocado leer mucho, ya escribiré mis comentarios sobre ellos. Uno de los libros que he terminado de leer hace poco es el CEH v9 Certified Ethical Hacker Version 9 Study Guide de Sean-Philip Oriyano.
En general este es un buen libro, el contenido es muy explicativo y lo puede entender, a mi parecer, un estudiante de primer año de ingeniería, eso lo transforma, como el título promete, en una buena guía de estudio, sin emabrgo, el libro es muy CEH, es decir, la práctica corre por tu cuenta y deberás invertir bastante tiempo en armar tu propio laboratorio para aplicar los conceptos que ahí se explican. ¡fantástico!, si quieres ser hacker no debes preocuparte por el trabajo que se asigna, ¡esa es la parte entretenida ¿no?!.

CEH v9 Certified Ethical Hacker Version 9 Study Guide de Sean-Philip Oriyano
Sean Oriyano (www.oriyano.com) es un experimentado profesional de la seguridad y empresario. En los últimos 25 años ha dividido su tiempo entre la escritura, la investigación, la consultoría y la formación de varias personas y organizaciones sobre una amplia gama de temas relacionados con TI y seguridad. Como instructor y consultor, Sean ha viajado por todo el mundo, compartiendo sus conocimientos, así como ganando exposición a muchos ambientes y culturas diferentes en el camino. Su amplio conocimiento y su manera fácil de entender, junto con una saludable dosis de humor, han llevado a Sean a ser un instructor solicitado regularmente.
Fuera de sus propias actividades comerciales, Sean es miembro del ejército como oficial jefe de órdenes especializado en infraestructura y seguridad, así como en el desarrollo de nuevas tropas. Además, como CWO es reconocido como un experto en la materia en su campo y con frecuencia es llamado a proporcionar experiencia, capacitación y tutoría donde sea necesario.
Cuando no trabaja, Sean es un ávido corredor de carreras de obstáculos, habiendo completado numerosas carreras, incluyendo una carrera de campeonato mundial y una Trifecta Espartana. También le gusta viajar, culturismo, entrenamiento, y el desarrollo de sus habilidades de artes marciales mixtas además de tomar cursos de supervivencia.
Sean posee muchas certificaciones y cualificaciones que demuestran su conocimiento y experiencia en el campo de TI, como el CISSP, CNDA y Security+.

Tags:

Estado estacionario de una cadena Markov

Aquí se presentan algunos cálculos de álgebra lineal básica y simulación a través de un simple ejemplo de cadena Markov. Considere una ciudad teórica, donde el clima se describe por tres estados posibles: (1) 'Fine', (2) 'Cloudy' y (3) 'Rain'. En cada día, dado un cierto estado, hay una distribución de probabilidad para el estado del tiempo del día siguiente. Este modelo meteorológico simplista constituye una cadena Markov discreta (homogénea). Esta cadena de Markov puede ser descrita por la Matriz de Probabilidad de Transición, P, donde la entrada Pi,jindica la probabilidad de pasar al estado jdado que el estado actual es i. Las probabilidades de transición se ilustran en la Figura 1.8.
Una cantidad calculada importante para un modelo de este tipo es la proporción a largo plazo de ocupación en cada estado. Es decir, en estado estacionario, qué proporción del tiempo es el clima en el estado 1, 2 o 3. La obtención de esta distribución estacionaria, denotada por el vector π = [π1, π2, π3](o una aproximación de este), se puede lograr de varias maneras. Por razones pedagógicas y exploratorias utilizamos los siguientes cuatro métodos para resolver la distribución estacionaria:

1. Al elevar la matriz P a una alta potencia, (repetida multiplicación de matriz de Pconsigo mismo), la distribución limitante se obtiene en cualquier fila. Matemáticamente,

πi = limn→∞[Pn]j,i para cualquier index, j.

2. Resolvemos el sistema lineal (sobredeterminado) de ecuaciones,
πP = π   and   sum(i=1-->3) πi=1

Este sistema lineal de ecuaciones se puede reorganizar en un sistema con 3 ecuaciones y 3 incógnitas al darse cuenta de que una de las ecuaciones dentro de πP = πes redundante.

3. Al hacer uso del hecho conocido (Perron Frobenius Theorem) que el eigenvector correspondiente al valor propio de la magnitud máxima, es proporcional a la palabra π. Encontramos este eigenvector y lo normalizamos.

4. Ejecutamos una simple simulación de Monte Carlo generando valores aleatorios del clima de acuerdo con P, y luego tomamos las proporciones a largo plazo de cada estado.

using LinearAlgebra, StatsBase

## Transition probability matrix
P = [0.5 0.4 0.1;
0.3 0.2 0.5;
0.5 0.3 0.2]

##First way
piProb1 = (P^100)[1,:]

##Second way
A = vcat((P' - I)[1:2,:],ones(3)')
b = [0 0 1]'
piProb2 = A\b

##third way
eigVecs = eigvecs(copy(P'))
highestVec = eigVecs[:,findmax(abs.(eigvals(P)))[2]]
piProb3 = Array{Float64}(highestVec) /norm(highestVec,1);

##Fourth way
numInState = zeros(3)
state = 1
N = 10^6
for t in 1:N
numInState[state] += 1
global state = sample(1:3,weights(P[state,:]))
end
piProb4 = numInState/N

[piProb1 piProb2 piProb3 piProb4] ##this dont work

print(piProb1, piProb2, piProb3, piProb4)

julia>
[0.4375, 0.3125, 0.25][0.4375; 0.3125; 0.25][0.4375, 0.3125, 0.25][0.437279, 0.312761, 0.24996]

Referencia:

[1]  H. Yoni y Y. Nazarathy, Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence [DRAFT]. 2019.

He terminado de leer el libro Beginning Julia Programming For Engineers and Scientists de Sandeep Nagar, este es un libro fantástico para introducirse en temas como ciencia de datos, el aprendizaje automático y las aplicaciones de computación científica.
El libro refleja muy bien como Julia es un lenguaje de programación fantástico y tan fácil de usar como R y Python, aunque personalmente Python lo encuentro increíblemente bueno, pero Julia es un lenguaje que es mucho más intuitivo y ágil para programar sistemas con operaciones complejas y las librerías Numpy, Scikit-Learn y Panda de Python parecen código espagueti al lado de los packages de Julia. Lo siento, se tenía que decir, y se dijo.
El libro en si trata temas como instalación, trabajo con paquetes, Orientación a Objetos, matemáticas básicas desde REPL (read-eval-print loop), números complejos, números racionales e irracionales, funciones, arrays, matrices, string, control de flujos, entrada y salida y plotting y visualización de gráficos.
Sin embargo, la versión 0.5.0 de Julia utilizada en el libro es muy antigua respecto de la actual versión 1.1.1, esto hace que algunas instrucciones y código de ejemplo del libro estén obsoletas o su sintaxis deba ser actualizada para que el código funcione, pero no le restan valor a todo lo que puede aprender sobre este fantástico lenguaje de programación.
Sin duda es un gran trabajo el que hizo Sandeep Nagar con su libro que para mi sorpresa es el mimso autor de un libro de Octave, que alguna vez también estudié, pero no escribí sobre ello.


Beginning Julia Programming For Engineers and Scientists de Sandeep Nagar

Autor
Sandeep Nagar. PhD in material science de KTH. Profesor en G. D. Goenka University y consultor Julia para la ciencia de datos / análisis.

 

Gráficos en Julia

Para machine learning y data science, es indispensable la gráfica de datos, en Julia un ploteo es un objeto gráfico que requiere un terminal gráfico.
Un objeto gráfico tiene muchas propiedades. Los siguientes son algunos de ellos:

  • Tamaño: Longitud y amplitud de una parcela tal como aparece en un terminal de gráficos

  • Forma: Relación de aspecto (la relación de longitud y amplitud de una gráfica)

  • Título: La cadena que declara el tema de una trama

  • Ejes: Los ejes que muestran puntosde datos de referencia

  • Etiquetas: Las etiquetas asociadasa ejes que muestran una cadena descriptiva

  • Marcadores: Símbolos de varias formas que representan puntos de datos

  • Resolución: Medida en ppp (puntos por pulgada) porque, durante la impresión, la resolución de una imagen viene determinada por la capacidad de la impresora para definir píxeles individuales como un punto y el número de puntos por pulgada definirá el grado de pixelación de la figura

  • Formato de archivo: Una gráfica se puede almacenar en muchos formatos reservados para fotografías y otro tipo de medios.

  • Nombre de archivo: Un nombre de archivo proporciona un marcador de identificación para un objeto en un sistema informático.

Un objeto de trazado Julia tiene un método para tratar con todas estas propiedades. Con este método, puede modificar las entidades. Es posible guardar un perfil para que todos los objetos puedan derivar valores para sus propiedades del perfil, evitando así la necesidad de definirlos cada vez que se necesite crear un nuevo objeto y también mantener la uniformidad.
Además, un objeto de trazado se representa mediante un motor gráfico. Una vez más se puede utilizar una variedad de motores de gráficos de diferentes capacidades. Algunos son más poderosos en términos de sus habilidades para producir parcelas de propiedades más ricas y producirlas más rápido. Mientras se trabaja con diferentes paquetes, algunos motores de gráficos proporcionan una manera de definir un motor determinado para la representación en el back-end. La corrección de este aspecto alivia las preocupaciones sobre la uniformidad de las configuraciones, la calidad y los formatos de los objetos gráficos.
Plots Package
Plots es un paquete de trazado de alto nivel. Proporciona potentes capacidades gráficas que normalmente se desean para la mayoría de los requisitos informáticos de alto rendimiento. Se interconecta con otros paquetes de trazado (denominados back-ends o motores gráficos)para producir archivos gráficos de una manera flexible. Cada uno de estos back-ends gráficos también puede funcionar como paquetes de trazado independientes, pero Plots proporciona una interfaz fácil de usar, sencilla y coherente.
Antes de su uso, se debe importar un paquete en Julia mediante el comando import <packageName>:
julia>import Pkg

julia>Pkg.add("Plots")
 Updatingregistry at `~/.julia/registries/General`
 Updatinggit-repo `https://github.com/JuliaRegistries/General.git`
Resolvingpackage versions...
InstalledShowoff ─────────── v0.3.1
InstalledMeasures ────────── v0.3.0
. . .
julia>using Plots
[ Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]

julia>x = Array([1,2,3,4,5])
5-element Array{Int64,1}:
1
2
3
4
5

julia>y = x.^2
5-element Array{Int64,1}:
 1
 4
 9
16
25

julia> plot(x,y)

Es importante señalar que los colores y la resolución de las ventanas serán dictados porla configuración del terminal gráfico dentro del sistema operativo de la máquina del usuario.
También se pueden elegir otros motores de trazado para cambiar el comportamiento. Por ejemplo, las unicodeplots() se pueden invocar y utilizar de la siguiente manera:
julia>Pkg.add("UnicodePlots")
Resolvingpackage versions...
InstalledUnicodePlots ─ v1.1.0
 Updating`~/.julia/environments/v1.1/Project.toml`
  [b8865327]+ UnicodePlots v1.1.0
 Updating`~/.julia/environments/v1.1/Manifest.toml`
[b8865327]+ UnicodePlots v1.1.0

julia>Pkg.build("UnicodePlots")

julia>unicodeplots()
[ Info: Precompiling UnicodePlots [b8865327-cd53-5732-bb35-84acbb429228]
Plots.UnicodePlotsBackend()

julia>x=1:10e4;

julia> plot(x,y)

Julia proporciona una manera de pasar implícitamente un argumento para que los argumentos de la segunda trama existan mediante el uso de plot! () sintaxis, que cambia la gráfica original desde el ! la versión modifica el objeto existente producido por el comando plot().

julia> eq1(x) = sind(2x)+sin(3x)
eq1 (generic function with 1 method)

julia> plot!(eq1,1:500)

¿Necesita un histográma?, no hay problema:

julia>x = rand(20);

julia> Plots.bar(x)

Las gráficas de dispersión simplemente colocan un punto para los datos x e y en la coordenada hecha por x e y. En nuestro ejemplo, el eje x ha distribuido linealmente 100 números de 1 a 100 y el eje Y tiene 100 números aleatorios. El siguiente código Julia realiza el trabajo de trazar un gráfico de dispersión.

julia> x=1:100;

julia> y=randn(100);

julia> Plots.scatter(x,y)



Julia es un lenguaje de programación muy ágil y fexible y las gráfica se manejan muy fácilmente, tal como se puede hacer con R y Python, estos son ejemplos muy básico de su utilización, sin embargo, en https://juliaplots.github.io/podrá encontrar tutoriales y ejemplos fantásticos.

Nuevo Flickr




Love



Flickr y su nueva política ha hecho que mi antigua cuenta quede abandonada, publiqué fotos ahí desde el 2006, pero ahora es imposible ordenar las fotos para reducir la cantiad de fotos a solo 1000 según la nueva política, así que he decidido abrir un nuevo flickr y también estoy experimentando con 500px, que se ve bueno, pero aún no me convence, además desconozco aún su política, no se si 500px también tiene restriccion de imágenes o baja la resolución, etc.
Instagram, definitivamente no me gusta, no se por qué, tal vez solo sea la maña de huir de las modas.
Si alguno pasa por aquí, comente por favor, ¿Flickr o 500px?
No se como aún hay muchas personas que siguen usando esta red social. Ahora Edin Jusupovic (@oasace), dice en twitter que había "notado una anomalía estructural al mirar un volcado hexadecimal de un archivo de imagen de un origen desconocido sólo para descubrir que contenía lo que ahora entiende es una instrucción especial IPTC." El IPTC (International Press Telecommunications Council) establece normas técnicas de publicación, incluidas las de metadatos de imagen.


A través de esta técnica Facebook puede rastrear fotos fuera de su propia plataforma con un nivel de precisión inquietante sobre quién subió originalmente la foto (y mucho más), esta es otra forma de aprender asociaciones entre las personas, por ejemplo, la  Persona 1 subió un montón de las mismas fotos que Persona 2 ya había subido, ahora pude mostrar a los dos los mismos anuncios. O bien, podrá saber su preferencias políticas o sociales al descargar los memes que otros comparten y que tu descargas.

Enlace:
https://www.forbes.com/sites/zakdoffman/2019/07/14/facebook-is-embedding-hidden-codes-to-track-all-your-uploaded-photos-report/#1b2bf7501592

Presentaciones BSDCan

Los vídeos de presentaciones en BSDCan 2019 están en el canal de YouTube. Y también se pueden encontrar en el sitio de OpenBDS.

Tags:

Microsoft ha tomado razón y recomienda evitar C y C++, sin duda estos lenguajes ya no debiera usarse para programar sistemas, y en las universidades tampoco debieran enseñarlo, personalmente me ha tocado dictar clases de ese lenguaje.
Ahora Microsoft recomienda Rust, uno de mis lenguajes de programación favoritos, sus características de seguridad ayudan al programador a no cometer corrupción de memoria, pues obviamente siempre será mejor no cometer los errores, que ir tras ellos, a pesar de que existen herramientas de revisión de código.

En mantención

Si, mantencion, algunos diran que lo escribi mal, pero es que nosotros usamos esta palabra, no la que le sobra una U.
hoy fue el dia de la mantencion, me di el tiempo para arreglar la bici y el auto, el auto no pude hacer la mantencion que necesitaba pues me faltaba una herramienta fundamental, La Gata, ne la robaron y recien me di cuenta jajaja.
Con la bici si pude continuar con lo que habia dejado inconcluso, hace un par de dias le puse neumaticos nuevos uno Ozono y otro Kenda, veremos como se comportan pues los ultimos que conpre eran unos neumaticos lisos, de pista y no duraron nada, estos son multi uso y debieran aguantar mas exigencia que los de velodromo, ademas le habia hecho limpieza general retirando desperdicion de aceite y cosas que s epegan a la cadena al rodar.

Ahora le cambie los frenos pues la bici ya lloraba con los que tenia que no recuerdo la marca, ahora les puse unos Tekpro mas o menos descentes.

Tags:

He leído bastante este fin de semana a pesar del poco tiempo.
Indexación
El índice de un elemento es la dirección del mismo elemento dentro de una matriz. La indexación en Julia comienza a la 1. Por ejemplo, en una matriz 1D, el índice de un elemento es el número de la posición del elemento desde la izquierda. Julia no tiene indexación negativa. En otras palabras, los elementos sólo se pueden acercar desde la izquierda.
julia> a = [12,4,6,3,6]
5-element Array{Int64,1}:
12
4
6
3
6

julia> a[3]
6

julia> a[1]
12
Creación de subarrays utilizando : operador
Utilizando índices y el operador : puede crear subarrays. Esto se conoce a veces como cortar una matriz. Por ejemplo, si una matriz se almacena en una variable denominada a, entonces a[n:m] devolverá otra matriz con un elemento que comienza desde el índice n a m. Dado que los : definen un rango de elementos, a veces se conoce como operador de rango. El siguiente ejemplo hará que este concepto sea más claro:
julia> a = [12,4,6,3,6]
5-element Array{Int64,1}:
12
4
6
3
6

julia> a[2:4]
3-element Array{Int64,1}:
4
6
3

julia> a[range(2,length=4)]
4-element Array{Int64,1}:
4
6
3
6
fin
Usando la palabra clave end, se puede acceder al último elemento de una matriz de la siguiente manera:
julia> A = [1,2,3,4,5]
5-element Array{Int64,1}:
1
2
3
4
5

julia> A[1]
1

julia> A[end]
5

julia> A[end-2]
3
Esto también se puede utilizar para crear un subconjunto de una matriz determinada:
julia> a = collect(1:7)
7-element Array{Int64,1}:
1
2
3
4
5
6
7

julia> a[2:2:end]
3-element Array{Int64,1}:
2
4
6
a = collect(1:7) crea una matriz con números del 1 al 7. Después a[2:2:end] crea una nueva matriz que comienza con 2 y va hasta elfinal de la matriz original a en pasos de dos (elementos 2, 4, 6).
Un equipo de investigadores del MIT ha desarrollado un nuevo lenguaje de programación que, según los autores, facilita el ingreso a principiantes en el mundo de la inteligencia artificial.

En un artículo presentado esta semana en la conferencia de Diseño e Implementación de Lenguajes de Programación, los investigadores describen un novedoso sistema de programación probabilística llamado "Gen” cuya aplicación abarca desde temas como la visión por computador, robótica y estadísticas, y les abstrae de lidiar con ecuaciones y tener que escribir manualmente código de alto rendimiento. Gen también permite a los investigadores expertos escribir modelos sofisticados y algoritmos de inferencia, utilizados para tareas de predicción, que antes eran inviables.
Las principales contribuciones son:

  • Gen, un sistema de programación probabilística integrado en Julia, en el que los usuarios (i) definen modelos en lenguajes de modelado embebidos y (ii) implementan programas de inferencia de alto nivel en el lenguaje host.

  • Interfaz de función generativa, una abstracción de caja negra para modelos probabilísticos que separa la lógica para el cálculo eficiente del diseño del algoritmo de inferencia.

  • Tres lenguajes de modelado interoperables: uno que es Turing completo para una máxima expresividad del modelo, uno que es susceptible al análisis estático, y otro basado en TensorFlow.

  • Tres combinadores de funciones generativas (map, unfold, recurse), que producen funciones generativas que explotan patrones comunes de independencia condicional.

  • Una evaluación empírica de la expresividad y la eficiencia de inferencia del modelado de Gen en relación con otros sistemas en cinco desafiantes problemas de inferencia.

Para instalar Gen primero debe tener instalado Julia versión 1.0 o posterior, luego escribir ] para entrar en pkg: una vez en Pkg escribr add http://github.com/probcomp/Gen

julia>

(v1.1) pkg> add http://github.com/probcomp/Gen
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Cloning git-repo `http://github.com/probcomp/Gen`
Updating git-repo `http://github.com/probcomp/Gen`
Resolving package versions...
Installed PDMats ──────────────── v0.9.7
Installed Missings ────────────── v0.4.1
Installed QuadGK ──────────────── v2.0.3
Installed CommonSubexpressions ── v0.2.0
Installed OrderedCollections ──── v1.1.0
Installed JSON ────────────────── v0.20.0
Installed StaticArrays ────────── v0.11.0
Installed Distributions ───────── v0.19.2
Installed Rmath ───────────────── v0.5.0
Installed ForwardDiff ─────────── v0.10.3
Installed StatsFuns ───────────── v0.8.0
Installed SpecialFunctions ────── v0.7.2
Installed FunctionalCollections ─ v0.5.0
Installed ReverseDiff ─────────── v0.3.1
Installed StatsBase ───────────── v0.31.0
Installed DataStructures ──────── v0.17.0
Installed DiffResults ─────────── v0.0.4
Installed DiffRules ───────────── v0.0.10
Installed FunctionWrappers ────── v1.0.0
Installed Arpack ──────────────── v0.3.1
Installed Compat ──────────────── v2.1.0
Installed BinaryProvider ──────── v0.5.6
Updating `~/.julia/environments/v1.1/Project.toml`
[ea4f424c] + Gen v0.3.1 #master (http://github.com/probcomp/Gen)
  Updating `~/.julia/environments/v1.1/Manifest.toml`
[7d9fca2a] + Arpack v0.3.1
[9e28174c] + BinDeps v0.8.10
  [b99e7846] + BinaryProvider v0.5.6
[bbf7d656] + CommonSubexpressions v0.2.0
.
.
.
[cf7118a7] + UUIDs
[4ec0a83e] + Unicode
Building Rmath ───────────→ `~/.julia/packages/Rmath/Py9gH/deps/build.log`
Building SpecialFunctions → `~/.julia/packages/SpecialFunctions/fvheQ/deps/build.log`
Building Arpack ──────────→ `~/.julia/packages/Arpack/cu5By/deps/build.log`

Luego en Julia se debe indicar el uso del package.

julia> using Pkg; Pkg.test("Gen")
Testing Gen
Resolving package versions...
  Status `/var/folders/p1/2sjzc3f16dz8fjcg_05_vg5m0000gn/T/tmpZyh3dJ/Manifest.toml`
  [7d9fca2a] Arpack v0.3.1
[9e28174c] BinDeps v0.8.10
.
.
.

En el sitio de Gen[1] se proporciona la documentación y tutoriales que se pueden seguir para lograr los primeros resultados en esta versión muy preliminar. persnamente probé un ejemplo de programa muy corto que hace regresión lineal bayesiana: dado un conjunto de puntos en el plano (x, y), se quiere encontrar una línea que se adapte bien a ellos.

Hay tres componentes principales para un programa Gen típico.

En primer lugar, se define un modelo generativo: una función Julia, extendida con alguna sintaxis adicional, que, conceptualmente, simula un conjunto de datos falso. El modelo debajo de los ejemplos de los parámetros de slope e intercept y, a continuación, para cada una de las coordenadas x que acepta como entrada, muestrea una coordenada y correspondiente. Se nombran las decisiones aleatorias quese toman con @trace, por lo que se puede referir a ellas en el programa de inferencia.

using Gen

@gen function my_model(xs::Vector{Float64})
  slope = @trace(normal(0, 2), :slope)
  intercept = @trace(normal(0, 10), :intercept)
    for (i, x) in enumerate(xs)
        @trace(normal(slope * x + intercept, 1), "y-$i")
    end
end


En segundo lugar, se escribe un programa de inferencia que implementa un algoritmo para manipular los seguimientos de ejecución del modelo. Los programas de inferencia son código Julia regular y hacen uso de la biblioteca de inferencia estándar de Gen.

El siguiente programa de inferencia toma un conjunto de datos y ejecuta un algoritmo MCMC iterativo para ajustar los parámetros de pendiente e interceptación:

function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
    # Create a set of constraints fixing the
    # y coordinates to the observed y values
  constraints = choicemap()
    for (i, y) in enumerate(ys)
      constraints["y-$i"] = y
    end
 
    # Run the model, constrained by `constraints`,
    # to get an initial execution trace
  (trace, _) = generate(my_model, (xs,), constraints)
 
    # Iteratively update the slope then the intercept,
    # using Gen's metropolis_hastings operator.
    for iter=1:num_iters
      (trace, _) = metropolis_hastings(trace, select(:slope))
      (trace, _) = metropolis_hastings(trace, select(:intercept))
    end
 
    # From the final trace, read out the slope and
    # the intercept.
  choices = get_choices(trace)
    return (choices[:slope], choices[:intercept])
end

Finalmente se ejecuta el programa y se obtiene los resultado:
xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
(slope, intercept) = my_inference_program(xs, ys, 1000)
println("slope: $slope, intercept: $intercept")

La ejecución en REPL sería algo como lo siguiente:

julia> using Gen


julia> @gen function my_model(xs::Vector{Float64})
         slope = @trace(normal(0, 2), :slope)
         intercept = @trace(normal(0, 10), :intercept)
         for (i, x) in enumerate(xs)
               @trace(normal(slope * x + intercept, 1), "y-$i")
           end
     end
DynamicDSLFunction{Any}(Dict{Symbol,Any}(), Dict{Symbol,Any}(), Type[Array{Float64,1}], ##my_model#364, Bool[false], false)

julia> function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
         # Create a set of constraints fixing the
         # y coordinates to the observed y values
         constraints = choicemap()
         for (i, y) in enumerate(ys)
             constraints["y-$i"] = y
         end
        
         # Run the model, constrained by `constraints`,
         # to get an initial execution trace
         (trace, _) = generate(my_model, (xs,), constraints)
        
         # Iteratively update the slope then the intercept,
         # using Gen's metropolis_hastings operator.
         for iter=1:num_iters
             (trace, _) = metropolis_hastings(trace, select(:slope))
             (trace, _) = metropolis_hastings(trace, select(:intercept))
         end
        
         # From the final trace, read out the slope and
         # the intercept.
         choices = get_choices(trace)
         return (choices[:slope], choices[:intercept])
     end
my_inference_program (generic function with 1 method)

julia> xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
10-element Array{Float64,1}:
  1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

julia> ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
10-element Array{Float64,1}:
8.23
5.87
  3.99
2.59
0.23
-0.66
-3.53
-6.91
-7.24
-9.9

julia> (slope, intercept) = my_inference_program(xs, ys, 1000)
(-2.059831593709758, 10.979679334853522)

julia> println("slope: $slope, intercept: $intercept")
slope: -2.059831593709758, intercept: 10.979679334853522

Habrá que ver si los investigadores Marco F. Cusumano-Towner, Feras Saad, Alex Lew, Vikash Mansinghka, presentan alguna demo en el próximo JuliaCon [2] que estará muy bueno, espero haya streaming, el paper ACM original lo pueden descargar aquí[3].

[1] https://probcomp.github.io/Gen/
[2] https://pretalx.com/juliacon2019/talk/GVYCEL/
[3] https://dl.acm.org/citation.cfm?id=3314221.3314642

Sindicar

RSS Atom

Perfil

deoxyt2
Juan Rodrigo Anabalón R.
Website

Acerca de mi

He estado escribiendo sobre temas de seguridad en Livejournal desde el 2008 y en mi horrible y extinto MSN Spaces desde el 2006. En la actualidad, soy CISO en MonkeysLab y Presidente en ISSA Chile.




MonkeysLab




Copyleft

Copyleft: Atribuir con enlace.







Flickr


ISSA Chile



contador de visitas


contadores gratis

Último mes

November 2019
S M T W T F S
     12
3456789
10111213141516
17181920212223
24252627282930

Tags

Powered by LiveJournal.com
Designed by Lilia Ahner