No tienes acceso a esta clase

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

Funciones seccionadas

10/18
Recursos

Aportes 47

Preguntas 4

Ordenar por:

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

o inicia sesi贸n.

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 鈥渟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)

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