El blog de runjaj

Evolución de las retractaciones de artículos

runjaj — Thu, 11 Jun 2026 22:00:00 GMT

Hace unos días leía que se había retractado un artículo muy citado sobre los beneficios del uso de la IA en el aprendizaje. El resultado era muy contraintuitivo y, de hecho, no es cierto.

Esto me hizo pensar que últimamente han aumentado mucho el número de retractaciones de artículos de investigación y me planteé ver la evolución. De paso era una buena excusa para aprender un par de cosas sobre el procesado de datos con Julia y el paquete de análisis de datos Tidier.jl, que está inspirado en el tidyverse de R.

Carga de la librería

El uso es muy sencillo, solo tenemos que cargar la librería Tidier y ya se ocupa de todo:

using Tidier

Datos a procesar

Lo primero es encontrar una base de datos con artículos retirados. Afortunadamente Retraction Watch recoge esta información, que habitualmente se encuentra muy dispersa.

Tiene la base de datos en un fichero CSV que podemos leer:

rdb = read_csv("https://gitlab.com/crossref/retraction-watch-data/-/raw/main/retraction_watch.csv");

He añadido un ; para evitar la salida del comando, ya que muestra las primeras y las últimas entradas de la base de datos y no se trata de que la lectura de este post quede muy farragosa.

Podemos hacernos una idea de la estructura de la base de datos con @glimpse:

@glimpse rdb

Rows: 70529
Columns: 21
.Record ID     Union{Missing, Int64}70871, 70868, 70751, 70731, 70730, 70729, 70
.Title         Union{Missing, String}The Uptake of Apoptotic Cells Drives Coxiel
.Subject       Union{Missing, String}(BLS) Microbiology;(HSC) Medicine - General
.Institution   Union{Missing, String}Unité de Recherche sur les Maladies Infecti
.Journal       Union{Missing, String}PLoS Pathogens, PLoS Neglected Tropical Dis
.Publisher     Union{Missing, String}PLoS, PLoS, Elsevier, Springer - Nature Pub
.Country       Union{Missing, String}France, Senegal, Egypt, Saudi Arabia, China
.Author        Union{Missing, String}Marie Benoit;Eric Ghigo;Christian Capo;Didi
.URLS          Union{Missing, String}https://retractionwatch.com/?s=Didier+Raoul
.ArticleType   Union{Missing, String}Research Article;, Research Article;, Clini
.RetractionDateUnion{Missing, InlineStrings.String31}5/12/2026 0:00, 5/26/2026 0
.RetractionDOI Union{Missing, String}10.1371/journal.ppat.1014210, 10.1371/journ
.RetractionPubMedIDUnion{Missing, Int64}42118727, 42189775, 42139973, 0, 0, 0, 0
.OriginalPaperDateUnion{Missing, InlineStrings.String31}5/16/2008 0:00, 9/14/201
.OriginalPaperDOIUnion{Missing, String}10.1371/journal.ppat.1000066, 10.1371/jou
.OriginalPaperPubMedIDUnion{Missing, Int64}18483547, 20856858, 33045448, 0, 0, 0
.RetractionNatureUnion{Missing, InlineStrings.String31}Retraction, Retraction, R
.Reason        Union{Missing, String}Author Unresponsive;Concerns/Issues about H
.Paywalled     Union{Missing, InlineStrings.String7}No, No, No, No, No, No, No, 
.Notes         Union{Missing, String}missing, missing, missing, missing, missing
.Column21      Missing        missing, missing, missing, missing, missing, missi

Las columnas que nos van a interesar son RetractionDate y ArticleType, ya que me quiero centrar solo en los artículos de investigación. No quiero que aparezcan ni los estudios clínicos, comunicaciones a congresos o artículos de revisión.

Tabla con las estadísticas anuales

Tidier.jl es fantástico para trabajar con datos, es realmente sencillo. El procesado de las más de 70_000 entradas de la base de datos es casi instantáneo y con una sintaxis muy sencilla. Era la primera vez que lo utilizaba y solo me ha costado leer el tutorial y echar un par de vistazos a la documentación.

Todo el procesao se hace aquí:

tabla = @chain rdb begin
                @filter ArticleType=="Research Article;"
                @mutate(Year = year(mdy_hm(RetractionDate)))
                @group_by Year
                @summarise n=n()
                @arrange desc(Year)
        end

55×2 DataFrame

30 rows omitted

Row	Year	n
	Int64	Int64
1	2026	717
2	2025	3499
3	2024	5793
4	2023	11820
5	2022	4406
6	2021	4229
7	2020	2777
8	2019	2628
9	2018	1664
10	2017	1389
11	2016	1391
12	2015	1172
13	2014	790
⋮	⋮	⋮
44	1983	5
45	1982	5
46	1981	2
47	1980	3
48	1977	9
49	1975	2
50	1971	1
51	1970	1
52	1968	1
53	1967	2
54	1966	1
55	1960	1

Aquí hay una secuencia de operaciones para crear una tabla, que he llamado tabla, con el número de retrataciones por año:

Selección con @filter de las entradas de la base de datos que son artículos de investigación.
Creación de la columna Year a partir de la fecha de retirada del artículo.
Agrupamos con @group_by las entradas de la base de datos por años.
Con @summarise contamos el número de artículos en cada grupo.
Para que la tabla quede más arreglada, la ordenamos en orden descendente de año con @arrange.

Viendo la tabla, se observa como el número de retractaciones aumenta con los años.

Creación de figuras

Una tabla está bien, pero (casi) siempre es mejor un gráfico.

Hacer los gráficos también es muy sencillo:

ggplot(tabla, @aes(x=Year, y=n)) + 
    geom_line(color=:teal, linewidth=2) + 
    geom_point(color=:red, stroke=1, strokecolor="black", size=15, alpha=0.8) + 
    theme_light()

Puede resultar interesante representar en eje y en escala logarítmica, lo que también resulta muy sencillo:

ggplot(tabla, @aes(x=Year, y=n)) + 
    geom_line(color=:teal, linewidth=2) + 
    geom_point(color=:red, stroke=1, strokecolor="black", size=15, alpha=0.8) + 
    scale_y_log10() +
    theme_light()

Conclusión

La primera conclusion es que Tidier.jl es una maravilla. Es rápido y fácil de usar. Se entiende que tidyverse y ggplot sean razones por las que hay muchos usuarios de R.

La segunda conclusión es que entre el uso de la IA, la falta de honradez de algunos autores, la presión por publicar, etc. está haciendo que el número de retractaciones de papers se esté disparando y nada hace pensar que la situación vaya a mejorar. Todo lo contrario.

Como dibujar un diagrama de Bode con Julia

runjaj — Tue, 04 Jul 2023 22:00:00 GMT

Es frecuente recurrir a librerías especializadas en control de procesos, como puede ser Control System Toolbox de Matlab o ControlSystems.jl para representar los diagramas de Bode.

Vamos a ver que podemos representar estos diagramas utilizando Julia sin ninguna librería especializada. Esta entrada es la explicación larga de este toot:

¿Se puede dibujar un diagrama de #Bode en un toot con #julialang ?

using Plots
using DSP:unwrap!
G(s) = 3/(2s^2+s+1)*exp(-.5s)
x(ω) = real(G(im*ω))
y(ω) = imag(G(im*ω))
AR(ω) = √(x(ω)^2 + y(ω)^2)
φ(ω) = atan(y(ω)/x(ω))*180/pi
ω = 10.0.^(-1:0.001:1);
plot(ω, AR, xscale=:log10, yscale=:log10, xlabel="ω", ylabel="AR", legend=false)
φᵤ = unwrap!([φ(i) for i in ω]);
plot(ω, φᵤ, xscale=:log10, xlabel="ω", ylabel="φ", legend=false)

¡Se puede!

#control #procesos

Un ejemplo simple

Como ejemplo representaremos el diagrama de Bode de esta función de transferencia:

Empezamos definiendo la función de transferencia del ejemplo:

G(s) = (3s+1)/(s^2+4s+1)

A continuación hacemos el cambio de variable y encontramos la parte real y la parte imaginaria:

donde y es la frecuencia angular.

En Julia, simplemente tenemos que reproducir estas funciones:

x(ω) = real(G(im*ω))
y(ω) = imag(G(im*ω))

La razón de amplitudes es:

y el desfase es:

RA(ω) = sqrt(x(ω)^2 + y(ω)^2)
φ(ω) = atan(y(ω)/x(ω))*180/pi

Representaremos el diagrama de Bode para valores de entre 10^-2 y 10², calcularemos 100 puntos:

ω = 10 .^LinRange(-2, 2, 100)

100-element Vector{Float64}:
   0.010000000000000002
   0.010974987654930556
   0.012045035402587823
   0.013219411484660288
   0.014508287784959401
   0.015922827933410922
   0.017475284000076828
   0.019179102616724886
   0.0210490414451202
   0.023101297000831605
   ⋮
  47.50810162102798
  52.14008287999685
  57.2236765935022
  62.80291441834253
  68.92612104349695
  75.64633275546291
  83.02175681319744
  91.11627561154896
 100.0

Ya solo queda representar la razón de amplitudes frente a la frecuencia angular. Normalmente utilizo la librería Plots.jl para representar gráficos, pero quiero probar Makie.jl:

using CairoMakie

fig_RA = Figure()
ax_RA = Axis(fig_RA[1,1],
    xlabel = "ω", xscale = log10,
    ylabel = "RA", yscale = log10,
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(10))
lines!(ax_RA, ω, RA.(ω))
fig_RA

A continuación representaremos el desfase:

fig_φ = Figure()
ax_φ = Axis(fig_φ[1,1],
    xlabel = "ω", xscale = log10,
    ylabel = "φ",
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(4))
lines!(ax_φ, ω, φ.(ω))
fig_φ

Normalmente se dibujan las dos figuras juntas:

fig = Figure()
ax_RA = Axis(fig[1,1],
    xlabel = "ω", xscale = log10,
    ylabel = "RA", yscale = log10,
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(10))
ax_φ = Axis(fig[2,1],
    xlabel = "ω", xscale = log10,
    ylabel = "φ",
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(4))
lines!(ax_RA, ω, RA.(ω))
lines!(ax_φ, ω, φ.(ω))
fig

Solución a los dolores de cabeza del arco tangente

Veamos un caso más complejo:

G(s) = 20*(s+1)/(s*(s+5)*(s^2+2s+10))

x(ω) = real(G(im*ω))
y(ω) = imag(G(im*ω))

RA(ω) = sqrt(x(ω)^2 + y(ω)^2)
φ(ω) = atan(y(ω)/x(ω))*180/pi

ω = 10 .^LinRange(-2, 2, 1000)

fig = Figure()
ax_RA = Axis(fig[1,1],
    xlabel = "ω", xscale = log10,
    ylabel = "RA", yscale = log10,
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(10))
ax_φ = Axis(fig[2,1],
    xlabel = "ω", xscale = log10,
    ylabel = "φ",
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(4))
lines!(ax_RA, ω, RA.(ω))
lines!(ax_φ, ω, φ.(ω))
fig

Tenemos un problema y es que para un valor de de un poco más de 2 el desfase ha dado una vuelta, lo que provoca esa discontinuidad. Lo más sencillo para solucionar este problema es utilizar la función unwrap!() de la librería DSP.jl.

using DSP:unwrap!

φᵤ = unwrap!([φ(i) for i in ω])

fig_φ = Figure()
ax_φ = Axis(fig_φ[1,1],
    xlabel = "ω", xscale = log10,
    ylabel = "φ",
    xminorgridvisible=true, xminorticksvisible=true,
    xminorticks = IntervalsBetween(10),
    yminorgridvisible=true, yminorticksvisible=true,
    yminorticks = IntervalsBetween(4))
lines!(ax_φ, ω, φᵤ)
fig_φ

Es importante destacar que hemos aumentado en número de puntos para los que hemos calculado el desfase de 100 a 1000 para que el algoritmo detecte correctamente las vueltas.

Una función para no escribir tanto

Podemos crear una función que reuna todo el código anterior:

function bode(G; w_min=1e-2, w_max=1e2, puntos=100)
    x(ω) = real(G(im*ω))
    y(ω) = imag(G(im*ω))
    
    RA(ω) = sqrt(x(ω)^2 + y(ω)^2)
    φ(ω) = atan(y(ω)/x(ω))*180/pi
    
    ω = 10 .^LinRange(log10(w_min), log10(w_max), puntos)
    
    φᵤ = unwrap!([φ(i) for i in ω])
    
    fig = Figure()
    ax_RA = Axis(fig[1,1],
        xlabel = "ω", xscale = log10,
        ylabel = "RA", yscale = log10,
        xminorgridvisible=true, xminorticksvisible=true,
        xminorticks = IntervalsBetween(10),
        yminorgridvisible=true, yminorticksvisible=true,
        yminorticks = IntervalsBetween(10))
    ax_φ = Axis(fig[2,1],
        xlabel = "ω", xscale = log10,
        ylabel = "φ",
        xminorgridvisible=true, xminorticksvisible=true,
        xminorticks = IntervalsBetween(10),
        yminorgridvisible=true, yminorticksvisible=true,
        yminorticks = IntervalsBetween(4))
    lines!(ax_RA, ω, RA.(ω))
    lines!(ax_φ, ω, φᵤ)
    fig
end

bode (generic function with 1 method)

Comprobemos que funciona:

G(s) = 3/(2s^2+s+1)*exp(-.5s)

bode(G; w_min=0.1, w_max=10, puntos=500)

Conclusión

Como vemos crear una función que dibuje los diagramas de Bode (o de Nyquist, si nos apetece) no es complicado. Julia nos permite aplicar la teoría de manera prácticamente directa, ¡lo que es fantástico!

A partir de hay podemos crear nuevas funciones para crear nuestra propia caja de herramientas. ¿Ventajas? Conocemos exactamente lo que hace el código, además de aprender. ¿Inconvenientes? Es fácil caer en soluciones naïf que no tengan en cuenta algunos casos o que el código sea un tanto “chapucero”.

Como dibujar la curva característica de operación de un plan de muestreo simple con Julia

runjaj — Thu, 29 Jun 2023 22:00:00 GMT

En un plan de muestreo de aceptación la curva característica de operación muestra la probabilidad de aceptar () un lote en función de su nivel de calidad o fracción de disconformidades ().

A continuación vamos a ver como representar estas curvas con Julia. También se pueden representar con R, pero en este caso lo más sencillo es utilizar la librería AcceptanceSampling, a no ser que se quieran conocer los detalles de estas representaciones.

La curva característica de operación depende de tres factores:

La función de distribución que utilicemos para realizar el cálculo. Las opciones más habituales son:
- Atributos:
  - Hipergeométrica: Se utiliza cuando el tamaño del lote () es más de un 10% del tamaño del lote ().
  - Binomial: Una función más sencilla de utilizar. Se utiliza para lotes grandes, cuando el tamaño de muestra es menos de la décima parte del tamaño del lote.
  - Poisson: Todavía más sencilla de utilizar. Además de solo usarse para lotes grandes, los lotes deben tener una fracción de disconformidades pequeña, se debe cumplir la condición .
- Variables: En este caso se utiliza la función de distribución normal.
El tamaño de muestra.
El criterio de aceptación.

Una vez seleccionada la función de distribución a utilizar, solo hay que representar la función de distribución acumulada.

Atributos

Función hipergeométrica

La probabilidad de aceptación es:

donde:

es el tamaño del lote
es el tamaño de la muestra
es el criterio de aceptación
es la fracción de unidades no conformes, ( es el número de disconformidades)

Afortunadamente la librería ‘Distributions.jl’ dispone de la función hipergeométrica y de la función ‘cdf’ para calcular el valor acumulado. La probabilidad de aceptación para un determinado número de unidades disconformes es:

cdf(Hypergeometric(d, N-d, n), c)

La representación de la curva característica de operación es sencilla. Consideremos un ejemplo en el que el tamaño del lote es de 100 unidades, el tamaño de la muestra es de 30 y el criterio de aceptación es de 2.

En primer lugar, cargaremos las librerías necesarias y definiremos las variables necesarias:

using Plots, Distributions

N = 100
n = 30
c = 2

El paso siguiente será calcular las probabilidades de aceptación para los valores de disconformidades a reprentar. En este caso, realizamos el cálculo para un número de unidades no conformes entre 0 y :

Pa_h = [cdf(Hypergeometric(d, N-d, n), c) for d in 0:n]

31-element Vector{Float64}:
 1.0
 1.0
 1.0
 0.9748917748917749
 0.9205337617708752
 0.8423941179095819
 0.7491748936540039
 0.6495096592105398
 0.5504874262796146
 0.45720561264903326
 ⋮
 0.01129851497883193
 0.00785079636266406
 0.005398801057411702
 0.0036741919192677004
 0.0024744638231675373
 0.0016489752345220268
 0.0010871906717287551
 0.000709066446771754
 0.000457378125934434

Por último solo queda representar la curva característica de operación. Los función de distribución es discreta, por lo solo tenemos los puntos a representar. Añadimos las rectas entre ellos para que la curva quede más clara.

scatter((0:n)./N, Pa_h, legend=false, xlabel="p", ylabel="Pₐ",
    title="Función hipergeométrica, N = $N, n = $n, c = $c")
plot!((0:n)./N, Pa_h)

En la representación hemos puesto en el eje horizontal , pero podíamos haber dejado :

scatter(0:n, Pa_h, legend=false, xlabel="d", ylabel="Pₐ",
    title="Función hipergeométrica, n = $n, c = $c")
plot!(0:n, Pa_h)

Binomial

En el caso de utilizar la función de distribución binomial, la función a utilizar es:

El cálculo de esta probabilidad de aceptación en Julia es muy sencillo. Podemos definir esta función:

Pab(p, n, c) = cdf(Binomial(n, p), c)

Pab (generic function with 1 method)

Como antes calcularemos las probabilidades de aceptación:

Pa_b = [Pab(p, n, c) for p in (0:n)./N]

31-element Vector{Float64}:
 1.0
 0.9966822906811174
 0.9782821654563826
 0.9399309054788823
 0.8831034382506107
 0.8121788131469606
 0.7323995229740374
 0.6487466279614775
 0.5653963645627734
 0.4855308229719024
 ⋮
 0.02552420175680366
 0.019182250019449253
 0.014309325629217927
 0.01059587068342088
 0.007788748557464795
 0.005683539178846932
 0.004117070879324837
 0.002960509485902006
 0.00211317814888654

Ya solo queda representar la curva característica de operación de la misma manera que en el caso anterior:

scatter((0:n)./N, Pa_b, legend=false, xlabel="p", ylabel="Pₐ",
    title="Función binomial, n = $n, c = $c")
plot!((0:n)./N, Pa_b)

Poisson

En este caso la probabilidad de aceptación se calcula utilizando:

donde es el número de defectos medio y su valor es .

Nuevamente definimos una función para calcular la probabilidad de aceptación:

Pap(p, n, c) = cdf(Poisson(p*n), c)

Pap (generic function with 1 method)

Como en los casos anteriores, calculamos las probabilidades de aceptación a representar y realizamos el gráfico:

Pa_p = [Pap(p, n, c) for p in (0:n)./N]

scatter((0:n)./N, Pa_p, legend=false, xlabel="p", ylabel="Pₐ",
    title="Función Poisson, N = $N, n = $n, c = $c")
plot!((0:n)./N, Pa_p)

Comparativa

Podemos comparar las tres curvas características de operación:

plot((0:n)./N, [Pa_h, Pa_b, Pa_p], xlabel="p", ylabel="Pₐ",
    title="N = $N, n = $n, c = $c",
    label=["Hipergeomética" "Binomial" "Poisson"])

Variables

En el caso de los planes de aceptación para variables utilizaremos la función de distribución normal. A diferencia de las anteriores se trata de una función continua.

conocida

Si se conoce la desviación estándar histórica del parámetro de calidad, la probabilidad de aceptación se calcula en este caso como:

donde . es la función quantil o función distribución normal inversa.

Calcularemos la probabilidad de aceptación con la siguente función:

Pan(p, n, k) = ccdf(Normal(), (k+quantile(Normal(),p))*sqrt(n))

Pan (generic function with 1 method)

Ya estamos en condiciones de representar la curva característica de operación:

k = 1.5

Pa_n = [Pan(p, n, k) for p in 0:0.005:0.2]

41-element Vector{Float64}:
 1.0
 0.9999999980987077
 0.9999969958027363
 0.9998788367564669
 0.9987893528726985
 0.9941210214350168
 0.9814967563928896
 0.9562194005905845
 0.9151337992857759
 0.857743753688643
 ⋮
 0.002811706079611004
 0.001985874005899692
 0.0013964405045249688
 0.0009778385404111605
 0.0006819651249039486
 0.0004737792691404002
 0.00032792188789803315
 0.00022615204871624653
 0.00015542327098513168

plot(0:0.005:0.2, Pa_n, legend=false, xlabel="p", ylabel="Pₐ",
    title="σ conocida, n = $n, k = $k")

desconocida

En el caso de de no conocer la desviación estándar del parámetro de calidad, el cálculo de la probabilidad de aceptación es más complejo:

donde es el número de grados de libertad (), es el parámetro de no centralidad () y es la variable aleatoria. Esta probabilidad se basa en la función de distribución t de Student no central, se pueden encontrar más detalles en el capítulo 10 de Schilling y Neubauer (2009).

El cálculo de esta probabilidad de aceptación queda así:

Pat(p, n, k) = ccdf(NoncentralT(n-1, cquantile(Normal(),p)*sqrt(n)), k*sqrt(n))

Pat (generic function with 1 method)

La representación de la curva característica de operación queda así:

Pa_t = [Pat(p, n, k) for p in 0:0.005:0.2]

41-element Vector{Float64}:
 1.0
 0.9999599292245724
 0.9989007649319692
 0.9938636262857532
 0.9815087483518103
 0.9596717321709702
 0.9277552833689862
 0.8864701525825365
 0.8373792110645313
 0.7824662021030258
 ⋮
 0.03139203386176437
 0.02622867333858414
 0.021868911647756617
 0.018196928824707026
 0.01511166775538031
 0.012525377493174727
 0.01036219663833926
 0.008556807795388699
 0.007053182590451401

plot(0:0.005:0.2, Pa_t, legend=false, xlabel="p", ylabel="Pₐ",
    title="σ desconocida, n = $n, k = $k")

Comparación

Para finalizar podemos comparar las curvas caracerísticas calculadas más arriba:

plot(0:0.005:0.2, [Pa_n, Pa_t], xlabel="p", ylabel="Pₐ",
    label=["σ conocida" "σ desconocida"])

Conclusiones

Dibujar las curvas características de operación de Julia no es complicado, pero requiere un cierto conocimiento de la base estadística del muestreo de aceptación y de Julia. Si no se utilizan con una cierta frecuencia es fácil olvidar como se dibujan. De hecho mi principal interés al escribir este texto es tener en un solo lugar todas estas “recetas” para poder consultarlas más adelante.

Referencias

Schilling, Edward G., y Dean V. Neubauer. 2009. Acceptance Sampling in Quality Control. 2.ª ed. Chapman and Hall/CRC. https://doi.org/10.1201/9781584889533.

Simulación de un lazo de control con ModelingToolkit

runjaj — Sun, 21 May 2023 22:00:00 GMT

En la entrada anterior dedicada al cálculo numérico de la transformada de Laplace decía que es preferible simular las ecuaciones diferenciales directamente a utilizar el método de Talbot para estimar numéricamente la transformada de Laplace. La última opción solo la usaría para problemas sencillos en los que estamos trabajando con funciones de transferencia y nos puede dar pereza reescribir el problema.

Me quedé con ganas de plantear la simulación de esa entrada utilizando las ecuaciones diferenciales y métodos numéricos más potentes.

Planteamiento del modelo matemático

El sistema a controlar es el lazo de control por retroalimentación siguiente:

Código

Transformada inversa de Laplace numérica

runjaj — Sat, 20 May 2023 22:00:00 GMT

Es habitual cuando se trabaja el control de procesos utilizar la transformada de Laplace para convertir las ecuaciones diferenciales que describen el comportamiento dinámico de los diferentes componentes del lazo de control en ecuaciones algebráicas.

Aunque no es la mejor opción se puede realizar la transformada inversa de Laplace numéricamente. Para realizar las simulaciones utilizaremos el paquete de Julia InverseLaplace.jl que nos permite utilizar el método de Talbot de manera extremadamente simple.

Descripción del lazo de control

Vamos a plantear una lazo de control sencillo (Figura 1) compuesto por un controlador de tipo proporcional, un elemento final de control, un proceso a controlar y un medidor. Las variables de este lazo de control por retroalimentación son:

, variable controlada
, consigna, es decir, el valor deseado de la variable controlada
, valor medido de la variable controlada
, error
, acción de control
, variable manipulable

Código

(Re)Estrenando blog

runjaj — Mon, 15 May 2023 22:00:00 GMT

Hace muchos años mantuve un blog, Un pequeño paso para Neil, pero por cosas de la vida lo dejé morir de inanición. Últimamente me han vuelto las ganas de volver a escribir, así que quiero retomarlo.

Me da un poco de pereza volver a usar Wordpress, por lo que los estoy haciendo con Quarto.

En fin, iré escribiendo sobre lo que me apetece. Sobretodo serán cosas que querré recordar en el futuro, porque estoy harto de ir “redescubriendo” cosas que ya sabía e ido olvidando.

El blog no tiene comentarios porque me da pereza configurarlos. Lo más sencillo para contactar conmigo es via Mastodon.

¡A ver si consigo mantenerlo activo!

Planes de aceptación unilaterales por variables con Julia, R y hoja de cálculo

runjaj — Mon, 15 May 2023 22:00:00 GMT

Vamos a ver como se calcula el tamaño de muestra y el criterio de aceptación de un plan de muestreo de aceptación por variables. Vamos a utilizar el procedimiento 1 o k, es decir, nos enfrentamos a una situación en la que tenemos un límite unilateral de especificaciones, ya sea superior o inferior. Se puede encontrar la base teórica en Schilling y Neubauer (2009).

Base teórica

El tamaño de muestra y el criterio de aceptación dependen de los riesgos del productor y del comprador. El riesgo del productor viene caracterizado por el nivel de calidad aceptable (NCA) o , que es la fracción de unidades no conformes () con una probabilidad de rechazo . En cambio, el riesgo del comprador es un punto con una fracción de unidades no conformes o calidad límite asociada a una probabilidad de aceptación .

Distinguiremos dos situaciones:

La desviación estándar () histórica de la muestra es conocida:
La desviación estándar histórica de la muestra es desconocida: El cálculo de es el mismo, y el tamaño de muestra lo podemos calcular con la aproximación de Wallis:

Nota

La función es la función cuantil, también conocida como la inversa de la función de distribución:

A continuación veremos como se calcula esta función con una función de distribución normal estándar ( = 0 y = 1) con Julia, R y Excel/LibreOffice.

Nota

El símbolo indica que hay que tomar el número entero superior. Por ejemplo, .

La aplicación del criterio de aceptación consiste en calcular:

donde es el valor medio del parámetro de calidad de las unidades de nuestra muestra y es el límite inferior de especificaciones.

En el caso de que tengamos un límite superior de especificaciones () el cálculo es:

La muestra se acepta si se cumple la condición:

y se rechaza si:

En el caso de que no se conozca la desviación estándar histórica, se utilizará la de la muestra.

Cálculo con Julia

Para realizar el cálculo de la función cuantil utilizaremos el paquete Distributions.jl. Lo más sencillo es definir una función z(x) que calcule el cuantil:

using Distributions

z(x) = cquantile(Normal(),x)

z (generic function with 1 method)

Ejemplo

Seleccionar y para un plan de muestreo por variables que ofrezca el siguiente nivel de protección:

histórica conocida

Utilizando la Ecuación 1 es sencillo realizar este cálculo. El criterio de aceptación es:

p₁ = 0.02
α = 0.05
p₂ = 0.06
β = 0.10

k = (z(p₂)*z(α)+z(p₁)*z(β))/(z(α)+z(β))

1.773288309877038

Ya solo queda calcular el tamaño de muestra:

n = ceil(((z(α)+z(β))/(z(p₁)-z(p₂)))^2)

35.0

histórica desconocida

El criterio de aceptación es el mismo que calculado más arriba, por lo que solo hay que calcular el tamaño de muestra usando la aproximación de Wallis (Ecuación 2):

n = ceil(((z(α)+z(β))/(z(p₁)-z(p₂)))^2*(1+k^2/2))

89.0

Cálculo con R

En R procederemos de la misma manera, definiremos una función ‘z’ para calcular el cuantil. Utilizaremos ‘lower.tail=FALSE’ para obtener un resultado positivo.

z <- function(x){qnorm(x, lower.tail = FALSE)}

El cálculo del criterio de aceptación con conocida es similar al que hemos realizado antes con Julia:

p1 <- 0.02
alpha <- 0.05
p2 <- 0.06
beta <- 0.10

k <- (z(p2)*z(alpha)+z(p1)*z(beta))/(z(alpha)+z(beta))

[1] 1.773288

El tamaño de muestra se calcula igual que hemos hecho antes con Julia:

n <- ceiling(((z(alpha)+z(beta))/(z(p1)-z(p2)))^2)

[1] 35

Aunque podemos realizar los cálculos de esta manera, puede ser más cómodo recurrir a la biblioteca AcceptanceSampling. Se puede encontrar mucha información sobre la báse teórica de los planes de muestreo de aceptación y de su aplicación con R en el libro gratuito de Lawson (2021).

Cálculo con hojas de cálculo

En las principales hojas de cálculo (Excel, LibreOffice y Numbers), el cálculo de la función distribución normal inversa se realiza con la misma función: =ABS(DISTR.NORM.ESTAND.INV(B1)). En lo único que debemos fijarnos es que hay que tomar el valor absoluto para obtener un valor positivo.

Bibliografía

Lawson, John. 2021. An Introduction to Acceptance Sampling and SPC with R. First edition. CRC Press, Taylor and Francis Group. https://bookdown.org/lawson/an_introduction_to_acceptance_sampling_and_spc_with_r26/.

Schilling, Edward G., y Dean V. Neubauer. 2009. Acceptance Sampling in Quality Control. 2.ª ed. Chapman and Hall/CRC. https://doi.org/10.1201/9781584889533.