No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y m谩s a precio especial.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

1 D铆as
10 Hrs
6 Min
44 Seg

Funciones seccionadas

10/18
Recursos

Aportes 72

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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)

As铆 lo hice yo 馃

Dejo una lectura adicional de las funciones seccionadas ac谩

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
馃懢

este es el aporte del reto>

![](

#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()

Tambien se puede hacer con np.absolute

Les propongo un reto con lo que se vio en la clase es posible crear una grafica escalonada asi:

Como lo harian ustedes?

Hay una funci贸n muy interesante llamada 鈥渟igmoide鈥. 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:

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)
`def h(x):` ` return np.intp(x >= 0)` Encontre esta manera de hacerlo
Esta es mi observacion frente a una funcion seccionada vs una funcion algebraica: Una funci贸n seccionada se diferencia de cualquier otra porque ella se comporta de diferentes maneras claras y abruptas dependiendo del valor que ella misma evalu茅, generando una clara diferencia entre una funci贸n lineal donde esta funci贸n lineal independientemente de los valores que tom茅 esta funci贸n su comportamiento siempre ser谩 lineal. la clave que entiendo es que, la raz贸n por la cual es una funci贸n seccionada es que por cada valor que pasa, esta funci贸n se comporta de una manera brusca generando picos claros de modificaci贸n de su comportamiento. por otro lado, una funci贸n por ejemplo lineal, independientemente de los valores que tome siempre va a ser lineal, por ejemplo.
Gafico `# Definir el rango de valores xx = np.linspace(-10, 10, 100)# Calcular los valores de la funci贸n valor absolutoy = np.abs(x)` `# Graficar la funci贸n valor absolutoplt.plot(x, y)` `# Etiquetas de los ejes y t铆tuloplt.xlabel('x')plt.ylabel('|x|')plt.title('Gr谩fico de la funci贸n valor absoluto')` `# Mostrar la cuadr铆culaplt.grid(True)` `# Mostrar el gr谩ficoplt.show()`
Quise practicar con un ejemplo usando list comprenhension. Cualquier valor definido `a` para el `eje_y` usando `full()` y superponiendo los datos. ```python def f(k): Y = [(val+2) if val <= 2 else (val**2)-4 for val in k] return np.array(Y) k = np.linspace(-5,5, num=100) L = f(k) fig, ax = plt.subplots(figsize=(8,8)) ax.plot(k,L, color='#00CC00', ) ax.axhline(color='k') ax.axvline(color='k') ax.grid() plt.show() ``` ![](https://static.platzi.com/media/user_upload/image-ffdd116e-79ee-4239-bd10-a296e6238b23.jpg)
Una forma mas complicada. Utilizando Visual Studio: ![](https://static.platzi.com/media/user_upload/image-ddafb75e-7f77-4cc0-b038-344f476ff7b1.jpg) ![](https://static.platzi.com/media/user_upload/image-b84db7fb-2ac1-4b28-978a-c2aea65f791e.jpg)

Interesante el desarrollo de funciones seccionada. Ma el reto de valor absolute. Era casi el mismo valor solo que con numpy se cambia el valor a absolute.
![](

def f(x): 聽 聽 return abs(x) x=np.linspace(-10,10,1000)y =f(x) plt.plot(x,y)plt.grid()plt.show()
Esta clase se sinti贸 demasiado improvisada con todos los errores al momento de escribir el c贸digo. Eso hace perder la atenci贸n del tema. Da la sensaci贸n de que no se hubiera preparado la clase antes de grabarla. Deber铆a tener el c贸digo antes de la clase para que al escribirla, la explicaci贸n sea mas fluida y menos err谩tica.
En una parte del curso veremos funciones de activacion

Esta fue mi forma de resolverlo, sin embargo, he notado que numpy tiene una funci贸n especifica para esto jajaja

Por cierto, un dato curioso, si escriben un 鈥;鈥 despues del comando para graficar no ser谩 necesario escribir la linea de codigo 鈥減lt.show()鈥

def f(x):
  Y = np.zeros(len(x))
  for index, x in enumerate(x):
    if x < 0:
      Y[index] = x * -1
    elif x > 0:
      Y[index] = x
  return Y

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

plt.plot(x,y);
```js def abs(x): Y = np.zeros(len(x)) for id,x in enumerate(x): if x < 0: Y[id] = x*-1 elif x > 0: Y[id] = x return Y N=1000 x = np.linspace(-10,10, num=N) y = abs(x) plt.plot(x,y) plt.axhline(0,color='black',linestyle=':') plt.xlim([-5,5]) plt.ylim([-10,10]) plt.show() ```
Un poco largo, pero conservando la facilidad de lectura podr铆a ser `def H(X): ` ` salida = []` ` for x in X:` ` if x >= 0:` ` salida.append(1)` ` else:` ` salida.append(0)` ` return np.array(salida)`
![](https://static.platzi.com/media/user_upload/imagen-5aa7a4b5-0397-4bea-9506-7e77854dc668.jpg)
Otra forma de conseguir la funcion de Heaviside ```js def H(x): return x >=0 ```
Este tipo de funciones es 煤til en diversas situaciones, y aqu铆 hay algunas aplicaciones comunes: 1. **Ajuste de Datos Irregulares:** * Las funciones seccionadas son 煤tiles cuando se trabaja con conjuntos de datos que exhiben comportamientos distintos en diferentes rangos. Pueden utilizarse para ajustar de manera m谩s precisa una funci贸n a datos irregulares. 2. **Interpolaci贸n:** * En ciertas aplicaciones, se pueden utilizar funciones seccionadas para interpolar entre puntos conocidos. Cada segmento puede proporcionar una aproximaci贸n m谩s precisa del comportamiento local. 3. **Modelado de Fen贸menos F铆sicos Variables:** * En problemas de ingenier铆a y f铆sica, donde los fen贸menos pueden cambiar de manera significativa en diferentes condiciones, las funciones seccionadas pueden utilizarse para modelar estos cambios y proporcionar una representaci贸n m谩s precisa. 4. **Dise帽o de Curvas y Gr谩ficos:** * En dise帽o gr谩fico y animaci贸n, las funciones seccionadas se pueden emplear para crear curvas y formas complejas que est谩n compuestas por segmentos m谩s simples. 5. **Control de Sistemas Din谩micos:** * En ingenier铆a de control, las funciones seccionadas pueden utilizarse para representar caracter铆sticas no lineales de sistemas din谩micos, permitiendo un modelado m谩s preciso y un mejor dise帽o de controladores. 6. **Programaci贸n Lineal y No Lineal:** * En problemas de optimizaci贸n, las funciones seccionadas pueden ser 煤tiles en modelos lineales y no lineales para representar restricciones o relaciones no continuas de manera m谩s precisa. 7. **Compresi贸n de Datos:** * En t茅cnicas de compresi贸n de datos, las funciones seccionadas pueden utilizarse para aproximar datos complejos de manera m谩s eficiente.

Me encant贸 que para esta sesi贸n del curso pasaran los apuntes de clase, deber铆an hacerlo en todas las clases de platzi.

```python xvalues=np.linspace(-10,10,1000) yvalues=[] def step(x): if x>=0: return 1 else: return 0 for x in xvalues: yvalues.append(step(x)) plt.plot(xvalues,yvalues) plt.show() ```xvalues=np.linspace(-10,10,1000) yvalues=\[] def step(x): if x>=0: return 1 else: return 0 for x in xvalues: yvalues.append(step(x)) plt.plot(xvalues,yvalues) plt.show()
Hey dude: ![](https://drive.google.com/file/d/1hlwMUzsc7miCwGfgmc89iUGvLq4AfCxq/view?usp=share_link)
Tambi茅n se podr铆a utilizar el m茅todo @np.vectorize para construir la funci贸n, y as铆 se puede usar la primera definici贸n que di贸.

Funci贸n Absoluta

La funci贸n absoluta, denotada com煤nmente como |x|, es una funci贸n que toma un n煤mero real x como entrada y devuelve el valor absoluto de ese n煤mero como resultado. El valor absoluto de un n煤mero es la distancia entre ese n煤mero y el cero en la recta num茅rica, siempre siendo positivo o igual a cero. La funci贸n absoluta se puede definir como:

| x | = { x, si x >= 0, -x, si x < 0 }

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

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

y=f(x)

plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('|x|')
plt.title('Gr谩fica de la Funci贸n Absoluta')
plt.grid(True)
plt.show()

se puede usar esto:

<import numpy as np
import matplotlib.pyplot as plt

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

N = 1000
x = np.linspace(-10, 10, num=N)
y = [H(xi) for xi in x]

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

tambi茅n esto

<y = np.vectorize(H)(x)> 

Mi aporte:

def h(x):
    return 1 * (x >= 0)

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

plt.plot(x, y);

De esta manera se pueden hacer mas 鈥渆scalones鈥, simplemente agregando mas condicionales o 鈥渟ecciones鈥 a la funci贸n.

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

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

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

Encontre otra forma de resolver el problema que es vectorizar la funcion con np.vectorize(H)
se los dejo aqui 馃槂

import numpy as np

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

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

H_vectorized = np.vectorize(H)  # Vectorizamos la funci贸n H

result = H_vectorized(x)  # Aplicamos la funci贸n vectorizada a todo el array x
plt.plot(x,result)

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 escaln 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()