Funciones seccionadas

mi forma favorita de implementar esto es:

import numpy as np

def f(x):
    # np.int0 es un cast a números enteros
    return np.int0(x >= 0) 

Según yo así:

def f(x):
  return np.absolute(x)

x = np.linspace(-10,10, num=1000)

y=f(x)

plt.plot(x, y)

Dejo una lectura adicional de las funciones seccionadas acá

Así lo hice yo 🤔

Información resumida de esta clase
#EstudiantesDePlatzi

• Las funciones seccionadas son funciones que se comportan de manera diferente dependiendo de los trozos o secciones

• Las funciones seccionadas se definen H (x)

• enumerate es una función en Python que nos permite tener el índice y el elemento de un arreglo

• Existen muchas funciones seccionadas

• La función real valor absoluto se define sobre el conjunto de todos los números reales asignando a cada número real su respectivo valor absoluto

Me propuse un reto, crear esta función seccionada

En cierta manera, si cumplí el objetivo, pero me hace falta algo. En un futuro lo solucionaré (Si tienen alguna sugerencia. Lo agradecería mucho)

Código: Deepnote
👾

#Valor absoluto:

def f(x):

    lista = []

    for value in x:
        if value > 0:
            value = value
            lista.append(value)

        elif value < 0:
            value = value*-1
            lista.append(value)

        else:
            value = 0
            lista.append(value)
    
    return lista

N = 1000
x = np.linspace(-10,10,num=N)
y = f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

este es el aporte del reto>

![](

Tambien se puede hacer con np.absolute

Hay una función muy interesante llamada “sigmoide”. La función que representa una sigmoide es la siguiente:

f(x) = (1 + e^(-x))^(-1)

Donde e es el número de Euler.

Esta función tiene propiedades muy interesantes. Por ejemplo, se puede demostrar que su derivada es igual a:

f’(x) = f(x)*[1 - f(x)]

Pero lo que quiero resaltar es su comportamiento, el cual es muy similar al de la función escalón de Heaviside, ya que solo toma valores entre 0 y 1, es decir, su rango es (0, 1).

Esta función es muy usada cuando se trabaja con redes neuronales.

Si quieren implementar la función sigmoide en Python, aquí les dejo el código:

import numpy as np

def f(x):
    return (1 + np.exp(-x))**(-1)

Así se ve la gráfica de la función:

Acerca de las funciones de valor absoluto
https://www.varsitytutors.com/hotmath/hotmath_help/spanish/topics/absolute-value-functions

La gráfica de la función H(x) que se realizo en google colab en el minuto 7:30 no es la más precisa en términos matemáticos, el segmento de recta vertical no debe ir en la gráfica, es solo un detalle pero no menos importante.

Escalón de Heaviside, siguiendo la metodolia de las anteriores

def H(x):

    lista = []

    for value in x:
        if value >= 0:
            value = 1
            lista.append(value)
        else:
            value = 0
            lista.append(value)

    return lista

N = 1000
x = np.linspace(-10,10,num=N)
y = H(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

Esta clase es un preambulo de lo que podemos ver en una función logistica para modelos de ML para regresiones logísticas. Importante repasar bien esta clase.

La función escalón se ocupa en redes neuronales

Así realice la solución al problema propuesto

def Abs_value(x):
    Y=np.zeros(len(x))
    for idx,x in enumerate(x):
        if x >= 0:
            Y[idx]=x
        else:
            Y[idx]=-x
    return Y

A=1000
x=np.linspace(-5, 5, num=A)
y=Abs_value(x)

fig,ax = plt.subplots()
ax.plot(x,y)
ax.grid(linestyle='--')
plt.title("Funciones a trozos - Valor Abs")

![](

Sé que se puede utilizar la función abs() para hacerlo de forma más fácil pero definiendo una función absoluta como una función seccionada sería así.

def f(x):
    y = np.zeros_like(x)
    for i,v in enumerate(x):
        if v < 0:
            y[i] = -v
        elif v >= 0:
            y[i] = v
    return y
    
x = np.linspace(-10,10, num=100)
y = f(x)
plt.plot(x,y)

Según yo, así funciona para sacar la gráfica de la función de valor absoluto. Si estoy bien o mal, muchas gracias por los comentarios y tomaré nota.

def Abs(x):
  Y = np.zeros(len(x))
  for idx,x in enumerate(x):
    if x<0:
      Y[idx]=x*-1
    else:
      Y[idx]=x
  return Y
    

N=1000

x = np.linspace(-10,10, num=N)

y = Abs(x)

plt.plot(x,y)

Comparto con ustedes la función de Heaviside.
Debemos tomar en cuenta que el segmento de recta vertical no debe ir en la gráfica como lo hace Google Colab en el video.

Yo así le hice, veo que hay muchas formas de hacerlo, no duden en compartir su forma 😃

Función de valor absoluto

Por definición, el valor absoluto de x siempre será mayor o igual que cero y nunca negativo.

def f_abs (x):
  return np.abs(x)

y = f_abs(x)
plt.plot(x,y)

<code> 
def valorab(x):
Y = np.zeros(len(x))
for idx,x in enumerate(x):
	if x < 0:
	Y[idx]=x*-1
else:
	Y[idx]=x
return Y

x = np.linspace(-100,100,num=200)
y = valorab(x)
plt.plot(x,y)

Una forma fácil y rápida para crear el valor absoluto

def f(x):
    return abs(x) 
y=f(x)
plt.plot(x,y)
plt.grid()
plt.axhline(0,color='gray', alpha=0.5 )
plt.axvline(0,color='gray',alpha=0.5 )
plt.show()

Pongo el codigo identico en COLAB y me sale una linea a una altura de 1 siempre 😦

<def f(x):
  Y= np.zeros(len(x))
  for idx, x in enumerate(x):
    if x>=0:
      Y[idx]=x
    else:
      Y[idx]=-x
  return Y
N=1000
x=np.linspace(-10,10,num=N)
y=f(x)    
plt.plot(x,y)> 

Fue confuso el codigo de ejemplo en Google colab.

import numpy as np
import matplotlib.pyplot as plt

N = 1000


def H(x):
    Y = np.zeros(len(x))
    for idx, x in enumerate(x):
        if x >= 0:
            Y[idx]=1
    return Y

x = np.linspace(-10, 10, num=N)
y = H(x)

plt.plot(x, y)

import matplotlib.pyplot as plt
import numpy as np

def f(x):
    Y=np.zeros(len(x))
    for idx, b in enumerate(x):
        if b >= 0:
            Y[idx]=b
        else:
            Y[idx]=-b
    return Y

N=11
x =np.linspace(-10,10, num = N)
y = f(x)
plt.plot(x,y)

3 formas de hacer la función valor absoluto :

1. la chipi

def f(x):
    return np.abs(x)
    
x=np.linspace(-5,5,150)
plt.plot(x,f(x))

1. la python de puro

def f(x):
    lista=[]
    for i ,j in enumerate(x):
        if j <0:
            lista.append(j*-1)
        else:
            lista.append(j)
    return lista

x=np.linspace(-5,5,100)
y=f(x)
plt.plot(x,y)

3.con numpy(copia de profe)

def f(x):
    lista=np.zeros(len(x))
    for i ,j in enumerate(x):
        if j <0:
            lista[i]=j*-1
        else:
            lista[i]=j
    return lista

x=np.linspace(-5,5,100)
y=f(x)
plt.plot(x,y)

import matplotlib.pyplot as plt   
import numpy as np                
def f(x):
  return np.absolute(x)
x = np.linspace(-10,10, num=1000)
y=f(x)
fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid(".")
plt.axvline(x=0, color='grey')
plt.axhline(y=0, color='grey')

Para el caso de la primera funcion, lo hice de la siguiente manera:

import numpy as np
import matplotlib.pyplot as plt

def H(x):
    if x<0:
        return 0
    else:
        return 1

x = np.linspace(-10,10,100)

lista = list(map(H,x)) 
y = np.array(lista)

plt.plot(x,y)
plt.grid()
plt.show()

reto

Veámosla en acción para dibujar la función campana de Gauss:

Elegiremos 1000 valores en el intervalo para una distribución normal de media y desviación estándar .

import matplotlib.pyplot as plt
import numpy as np
import math

num_puntos = 1000
x_min = -5
x_max = 5
lista_x = np.linspace(x_min, x_max, num_puntos)

media = 0
desviacion_estandar = 1
factor = 1./(desviacion_estandar*math.sqrt(2*math.pi))
den = 2*desviacion_estandar**2

lista_y = [0]*num_puntos
for i, x in enumerate(lista_x):
    lista_y[i] = factor*math.exp((-(x-media)**2)/den)

plt.plot(lista_x, lista_y)
plt.title('Distribución de Gauss')
plt.xlabel('$x$')
plt.ylabel('$N({},{})$'.format(media, desviacion_estandar))
plt.show()

crea una tira de ceros de la misma longitud que la entrada X y solo cambia a 1 las mismas posiciones en las que X es >=0

Otra forma de hacerlo:

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

def f(x):
  y= x.copy()
  y[y>=0], y[y<0] = 1, 0
  return y

x = np.linspace(-10, 10, num=1000)
y = f(x)

#Graphic
fig = plt.figure()
axes = fig.add_axes([0, 0, 1, 1])
axes.plot(x, y, linewidth=3, color=c_1)
axes.set_title('Función escalón de Headivise\n')
axes.set_xlabel('x')
axes.set_ylabel('y')
fig.set_facecolor(color=c_2)
fig.show()

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
#RETO: FUNCIÓN VALOR ABSOLUTO
#Dos maneras de hacerlo:
#1
def f(x):
  Y = x.copy()
  for idx, num in enumerate(x):
    if num < 0:
      Y[idx] *= -1
  return Y
#2
def f(x):
  y = x.copy()
  y[y<0] *= -1
  return y

x = np.linspace(-10, 10, num=1000)
y = f(x)

#Graphic
sns.set_theme(style='darkgrid')
fig = plt.figure()
axes = fig.add_axes([0, 0, 1, 1])
axes.plot(x, y, linewidth=3, color='#000080')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('Función de valor absoluto\n')
fig.set_facecolor('#AAA662')
fig.show()

algo me dice que nuestro querido teacher se complico un poco.

Pd. es la primera ves que veo estas cosas.

Mi forma de implementar la función de valor absoluto

plt.plot(x, np.absolute(x))

Adicionalmente la clase me sirvió para repasar la función enumerate.

Adjunto mi reto

Reto, parte 1:

.abs(): Lo que hace esta función, como su nombre lo indica, es pasar a su valor absoluto. El valor absoluto es el valor positivo de este (-3 → 3). Cuándo el valor es positivo, se deja positivo (3→3)

Puedes entender más sobre el tema en este Artículo (Está en inglés, aprovecha para practicar tu reading)

def f(x):
    return np.abs(x)

y = f(x)

plt.title('Abs Value')
plt.plot(x,y);
plt.grid()

Mi aporte!

N = 1000
x = np.linspace(-10,10,num=N)

def H(x):
  Y = np.zeros(len(x))
  for idx, x in enumerate(x):
    if x <= 0:
      Y[idx] = -x
    else:
      Y[idx] = x  
  return Y    

plt.plot(x,H(x));

Funciones absolutas

Las Funciones absolutas son aquellas que se encuentran dentro de el valor absoluto es decir tenemos una función algebráica y para que sea una función absoluta esta se tiene que meter dentro de los símbolos del valor absoluto

Mi Código para solucionarlo es este

<code> 

def f(x):
  return abs(4 + 2*x)

n = 1000

x = np.linspace(-10, 10, num=n)

y = f(x)

plt.plot(x,y)
plt.grid()

El resultado de esto es

FUNCIÓN ABSOLUTO

N = 1000

x = np.linspace(-10, 10, num = N)

plt.plot(x, np.absolute(x))
plt.grid()

Dejo mi implementación de la función absoluta

def f(x):
  return np.absolute(x)
N = 1000
x = np.linspace(-10,10,num=N)
y = f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

https://prezi.com/x4wwr2ygy7ey/funcion-seccionada/ dejpoo aqui unas dias positivas