A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Funciones afines

15/28
Recursos

Aportes 43

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Aqu铆 mi aporte del ultimo problema, me llevo algo de rato, ya que es un tema que tenia rato de no ver, tuve que repasar algunos conceptos de matrices, hacer varias preguntas鈥 XD, lo que explicare ser谩 la forma de obtener los valores de a y b:

hay distintas formas de ver este problema para llegar a la soluci贸n, una vez termin茅 de ver la clase, lo primero hice fue tratar de implementar alg煤n c贸digo para encontrar los vectores a y b, como no llegaba a nada, toco plantear el sistema de ecuaciones

35 = [a0 a1 a2][10 10 10] + b
60 = [a0 a1 a2][100 10 10] + b
75 = [a0 a1 a2][10 100 10] + b
65 = [a0 a1 a2][10 10 100] + b

cada ecuaci贸n representa las situaciones descritas en el problemas

operando las matrices a y p como indica la funci贸n, se obtiene lo siguiente
35 = 10 a0 + 10 a1 + 10 a2 + b
60 = 100 a0 + 10 a1 + 10 a2 + b
75 = 10 a0 + 100 a1 + 10 a2 + b
65 = 10 a0 + 10 a1 + 100 a2 + b
as铆 tenemos un sistema de 4 ecuaciones y 4 inc贸gnitas, que es posible resolver de distintas formas, una de ellas es escribir el sistema en su forma matricial, el termino 鈥渕atricial鈥 no se ha usado mucho hasta ahora en el curso, pero es como si habl谩ramos de stacks de vectores. este sistema se puede resolver con la funci贸n linalg.solve de Numpy, la cual nos devolvera en un array con los valores de a0, a1, a2 y b, aqui les dejo un video con explicacion y el codigo implementado
https://www.youtube.com/watch?v=G28bJYdqOFQ

import numpy as np

def run():
    
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"

    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b

    print(a)

if __name__ == "__main__":
    run()

ejecutando, tenemos el siguiente output:

por lo tanto a0=0.2777778, a1=0.3888889, a2=0.33333 y b=25
as铆 ya hemos encontrado las entradas del vector a y el valor de b, y podemos escribir nuestra funci贸n T搂=a*P+b

ahora bien, si vienen siguiendo la ruta de aprendizaje de escuela de Data Science, habr谩n pasado por algunos cursos del profesor David Aroesti o el curso de matem谩ticas para data Science: probabilidad. https://platzi.com/clases/ds-probabilidad/ del profesor Francisco Camacho, que fue agregado recientemente. en ellos se nos ha hablado de la regresi贸n lineal o el metodo de minimos cuadrados, los cuales son altamente aplicables en este problema.

si usamos otro enfoque, lo que tenemos son una serie de datos experimentales que corresponden las temperaturas obtenidas seg煤n la configuraci贸n de los procesadores, entonces requerimos una funci贸n o polinomio que se ajuste al comportamiento de los datos, para nuestra suerte, el ejercicio nos dice que esta funci贸n es af铆n, T搂=aP+b lo que nos indica que buscamos un polinomio de grado 1 de la forma y=ax+b, una funcion lineal, y benditas sean las librer铆as como numpy o Scikitlearn que nos brindan m茅todos para lograr esto, les comparto mi c贸digo, en donde se aplican varias formas de obtener los coeficientes a y el valor de b:

import numpy as np
from sklearn.linear_model import LinearRegression

def datos_experimentales():
    p_0=np.array([10,10,10]) #en reposo
    p_1=np.array([100,10,10])
    p_2=np.array([10,100,10])
    p_3=np.array([10,10,100])
    
    p=np.array([p_0,p_1,p_2,p_3])
    t=np.array([35,60,75,65])
    
    return p, t

def solucion_metodo1(): #resolvinedo el sistema de ecuaciones
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"
    
    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b
    return a

def solucion_metodo2(): #usando minimos cuadrados, numpy.linalg.lstsq
    # Experimental data:
    p,t=datos_experimentales()
    
    A = np.column_stack([p, np.ones(len(p))])
    coefs = np.linalg.lstsq(A, t, rcond=-1)[0]
    
    return coefs

def solucion_metodo3(): #regresion lineal con sklearn.linear_model
    model = LinearRegression()
    
    # Experimental data:
    p,t=datos_experimentales()

    model.fit(X=p, y=t)

    print("coeff: ", *model.coef_)
    print("intercept: ", model.intercept_)
    
def run():
    print("********metodo1, resolvinedo el sistema de ecuaciones*******")
    print(solucion_metodo1())
    print("********metodo2, usando minimos cuadrados, numpy.linalg.lstsq*******")
    print(solucion_metodo2())
    print("********metodo3, regresion lineal con sklearn.linear_model*******")
    solucion_metodo3()
if __name__ == "__main__":
    run()

Output:

Espero que esto ayude, hare otro aporte respondiendo a los incisos usando los resultados obtenidos aqu铆

Soluci贸n al problema 2:

Primer ejercicio:

Estuvo complejo el ejercicio mas que nada por la cantidad de datos, de hecho mi soluci贸n solo es aproximada, y bueno estos son mis datos:

Y la temperatura a la que los 3 procesadores trabajan al 100% (126.94) no rebasa la temperatura limite de 150:

Saludos 馃槂

Esta fue la aproximaci贸n que encontr茅, la A transpuesta est谩 definida en la funci贸n.


import numpy as np

def T(p):
    return np.array([112275/405449, 179925/405449, 134825/405449])[email protected] + 24.468

print("Cuando est谩n en reposo T=", T(np.array([10,10,10])),
      "\nCuando el procesador 1 est谩 al m谩ximo T=", T(np.array([100,10,10])),
      "\nCuando el procesador 2 est谩 al m谩ximo T=", T(np.array([10,100,10])),
      "\nCuando el procesador 3 est谩 al m谩ximo T=", T(np.array([10,10,100])),
      "\nCuando el todos los procesadores est谩n al m谩ximo T=", T(np.array([100,100,100])))

OUTPUT

Cuando estn en reposo T= 35.00015077605322 
Cuando el procesador 1 est谩 al m谩ximo T= 59.922520790530996 
Cuando el procesador 2 est谩 al m谩ximo T= 74.9392059963152 
Cuando el procesador 3 est谩 al m谩ximo T= 64.9280825257924 
Cuando el todos los procesadores estn al m谩ximo T= 129.78950776053216

Este es el c贸digo que use para encontrar el vector a

Estas fueron las operaciones que use para enontrar los valores de el vector a

import numpy as np
T = np.array([35, 60, 75, 65]).T
P = np.array([[10, 100, 10, 10],[10, 10, 100, 10],[10, 10, 10, 100],[1,1,1,1]])
P_inv= np.linalg.inv(P)
a_vec = T @ P_inv
print(a_vec)	

Esta es la funci贸n que hice

def funcion_de_temperatura(x):
  return f'T = {a @ x+ b} con P_1 = {x[0]}, P2= {x[1]}, P3 = {x[2]} '
#Para probar
v = np.array([10,10,10])
print(funcion_de_temperatura(v))
#Temperatura maxima potencia
max_p = np.array([100, 100 ,100])
print(funcion_de_temperatura(max_p))

Y el output

T = 35.00000000000001 con P_1 = 10, P2= 10, P3 = 10 
T = 130.0 con P_1 = 100, P2= 100, P3 = 100 

Con este algoritmo calcule los valores donde se aproximaba a 150
Primero puse una delta grande de .01 y despu茅s que ya sabia que era cercano a 18 empec茅 a contar desde 18

resultado = 0
potencia = 118
delta = 0.000001
while (1):
  v_c = np.array([potencia,potencia,potencia])
  resultado = funcion_de_temperatura_n(v_c)
  if resultado ==150 or resultado > 150:
    break
  potencia = potencia + delta
print(resultado , potencia)

output : 150 , 118.94736899760812
Ejecuntando lo

max_p = np.array([118.94736899760812, 118.94736899760812,118.94736899760812])
print(funcion_de_temperatura(max_p))

Output

T = 150.00000060858633 con P_1 = 118.94736899760812, P2= 118.94736899760812, P3 = 118.94736899760812 

驴Que temperatura se alcanza?
Para resolver esta pregunta tenemos que encontrar el vector a y el escalar b que satisfacen la ecuaci贸n: T( P ) = aT . P + b El procedimiento es plantear y resolver el siguiente sistema de ecuaciones lineales donde a0, a1 y a2 son las componentes del vector a encontrar:
35 = 10 a0 + 10 a1 + 10 a2 + b
60 = 100 a0 + 10 a1 + 10 a2 + b
75 = 10 a0 + 100 a1 + 10 a2 + b
65 = 10 a0 + 10 a1 + 100 a2 + b
El vector resultante ser铆a a = [5/18, 4/9, 1/3] y el escalar b = 220/9, de esta manera la ecuaci贸n del problema ser铆a esta: T( P ) = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9. La m谩xima potencia de cada procesador es 100 por lo que P = [100, 100, 100], al resolver la ecuaci贸n T( P ) = [5/18, 4/9, 1/3]T . [100, 100, 100] + 220/9 el resultado de la temperatura es 130.
.
驴Cual es la potencia m谩xima que pueden alcanzar los procesadores para que T <= 150?
Reescribamos la ecuaci贸n T( P ) = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9:
150 = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9
150 = 5/18 P0 + 4/9 P1 + 1/3 P2 + 220/9
150 = 5/18 P0 + 8/18 P1 + 6/18 P2 + 440/18
150 = (5 P0 + 8 P1 + 6 P2 + 440)/18
2700 = 5 P0 + 8 P1 + 6 P2 + 440
2260 = 5 P0 + 8 P1 + 6 P2
La potencia m谩xima puede ser descrita como una ecuaci贸n de dos variables donde las variables independientes ser谩n la potencia de dos de los tres procesadores y la variable dependiente nos indicar谩 la potencia m谩xima del procesador restante. Para hallar la potencia m谩xima se puede utilizar cualquiera de las siguientes tres ecuaciones:
P0max = ( 2260 - 8 P1 - 6 P2 )/5
P1max = ( 2260 - 5 P0 - 6 P2 )/8
P2max = ( 2260 - 5 P0 - 8 P1 )/6

Por si alguien no entendi贸 bien los dos puntos del Ejercicio:
En el primero, la propiedad de homogeneidad, por ende es lineal.
En el segundo, se cumple superposici贸n porque la suma de los escalares (los indices del vector) es 1.

aqui les compartto mi codigo final:

import numpy as np
from sklearn.linear_model import LinearRegression

def datos_experimentales():
    p_0=np.array([10,10,10]) #en reposo
    p_1=np.array([100,10,10])
    p_2=np.array([10,100,10])
    p_3=np.array([10,10,100])
    
    p=np.array([p_0,p_1,p_2,p_3])
    t=np.array([35,60,75,65])
    
    return p, t

def solucion_metodo1(): #resolvinedo el sistema de ecuaciones
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"
    
    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b
    return a

def solucion_metodo2(): #usando minimos cuadrados, numpy.linalg.lstsq
    # Experimental data:
    p,t=datos_experimentales()
    
    A = np.column_stack([p, np.ones(len(p))])
    coefs = np.linalg.lstsq(A, t, rcond=-1)[0]
    
    return coefs

def solucion_metodo3(): #regresion lineal con sklearn.linear_model
    # Experimental data:
    p,t=datos_experimentales()
    
    #primera forma:
    model = LinearRegression()

    model.fit(X=p, y=t)

    # print("coeff: ", *model.coef_)
    # print("intercept: ", model.intercept_)
    
    #segunda forma:
    reg = LinearRegression().fit(p, t)
    # print (reg.coef_, reg.intercept_)
    
    return reg.coef_, reg.intercept_
    
def T(p):
    a,b=solucion_metodo3()
    return [email protected]+b

    
def run():
    print("********metodo1, resolvinedo el sistema de ecuaciones*******")
    print(solucion_metodo1())
    print("")
    print("********metodo2, usando minimos cuadrados, numpy.linalg.lstsq*******")
    print(solucion_metodo2())
    print("")
    print("********metodo3, regresion lineal con sklearn.linear_model*******")
    print("coeff, intercept: ", solucion_metodo3())
    print("")
    
    p_max_capacity=np.array([100,100,100])
    print(f'la temperatura que se alcanza cuando los todos los procesadores estan a su maxima capacidad es de {T(p_max_capacity)}掳C')

Output:

Siendo la temperatura de fusi贸n de los procesadores 150掳C, los 3 podr铆an operar a su m谩xima capacidad sin que se derritan

  • Ejercicio 1
def p(x):
  long=len(x)
  ret= x[long-1] - x [0]
  return ret

v_a = np.array([1,9,12])
v_b = np.array([4,3,4])
x ,y = 1 , 9
print('p(x*v_a + y*v_b) = ',p(x*v_a + y*v_b))
print('x*f(v_a) + y*f(v_b) =',x*p(v_a) + y*p(v_b))

#output
p(x*v_a + y*v_b) =  11
x*f(v_a) + y*f(v_b) = 11

Por lo tanto si es lineal

  • Ejercicio 2
#funcion
def f_4(x):
    res = x[2] + (x [2] - x [1])
    return res
# main 
v_a = np.array([1,9,12,2])
v_b = np.array([4,3,4,9])
x ,y = 1 , 9
print('p(x*v_a + y*v_b) = ',f_4(x*v_a + y*v_b))
print('x*f(v_a) + y*f(v_b) =',x*f_4(v_a) + y*f_4(v_b))

#output
p(x*v_a + y*v_b) =  60
x*f(v_a) + y*f(v_b) = 60

La segunda funci贸n es lineal

As铆 fue como resolv铆 los primeros 2 ejercicios, con ejemplos. Estoy abierto a feedback (:

Para el tercer ejercicio tuve que ver ejemplos de algunos comentarios y not茅 que iba en la misma direcci贸n, dejo mi c贸digo en python:

import numpy as np
P = np.array([[10,10,10,1] , [100,10,10,1] , [10,100,10,1] , [10,10,100,1]])
T = np.array([35,60,75,65])
x = np.linalg.solve(P,T)
print(f"La soluci贸n para el sistema de ecuaciones lineales es {x}")

Resultado: La soluci贸n para el sistema de ecuaciones lineales es [ 0.27777778 0.44444444 0.33333333 24.44444444]

Otra soluci贸n, por el gusanito de estar mas aproximada,

import numpy as np
import sympy as sym
#en reposo
p_0=np.array([10,10,10,1]) 
#1 activado
p_1=np.array([100,10,10,1])
#2 activado
p_2=np.array([10,100,10,1])
#3 activado
p_3=np.array([10,10,100,1])

#coeficientes de la matriz
coef=np.array([p_0,p_1,p_2,p_3])
#soluciones
sol=np.array([35,60,75,65])
#solucionamos el sistema de ecuaciones
a=np.linalg.solve(coef,sol)

#miramos cuando la temperatura es igual a 150 
x = sym.symbols('x')
expr =a[0]*x+a[1]*x+a[2]*x+(a[3])-150
print(f'la potencia maxima que pueden alcanzar antes de que la temperatura sea superior a 150掳 es: {sym.solve(expr)[0]}')
#miramos la temperatura con los 3 procesadores funcionando
print(f'la temperatura con todos los procesadores encendidos es: {a[0]*100+a[1]*100+a[2]*100+(a[3])}掳')

la potencia maxima que pueden alcanzar antes de que la temperatura sea superior a 150掳 es: 118.947368421053
la temperatura con todos los procesadores encendidos es: 130.0掳

Buenas noches se realiza la soluci贸n solicitada:

Pude resolver ambos ejercicios, aunque me hubiese gustado resolver el 2ndo con lo aprendido en este curso, pero no fue suficiente para mi gusto 馃槥 . Lo resolv铆 usando matrices.

Ejercicio 1

def f_1(x):
    return x[len(x)-1] - x[0]

x = np.array([1,2,3,4,5])
y = np.array([7,8,9,10,11])
alpha = -2
beta = 1

f_1(alpha*x + beta*y) == alpha * f_1(x) + beta * f_1(y)

True

.
Entonces es una funci贸n lineal
.
.
.
.

Ejercicio 2

def f_2(x):
    return np.array([1, 0, -1, 1])@x

x = np.array([1,9,12,2])
y = np.array([4,3,4,9])
alpha = 1
alpha = 9

f_2(alpha*x + beta*y) == alpha*f_2(x) + beta*f(y)

True

.
Entonces esta tambien es una funci贸n lineal

La soluci贸n al ejercicio 3 propuesto en la clase:


El link de la clase de Platzi que utilice para resolver el ejercicio con python fue el siguiente:
https://platzi.com/clases/1725-algebra-lineal/23877-aplicacion-de-la-inversa-de-una-matriz-para-resolv/

El c贸digo implementado para resolver los problemas planteados fue el siguiente:

En el caso de resolver el sistema de ecuaciones:

import numpy as np

np.set_printoptions(suppress=True)

A = np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]])
b = np.array([[35],[60],[75],[65]])
inversa_A = np.linalg.inv(A)
x = inversa_A.dot(b)
print(x)

C贸digo para comprobar que el resultado sea el correcto:

print(A.dot(x))

C贸digo para responder la pregunta referente a la temperatura generara por los tres procesadores a su m谩ximo potencial:

a= np.array([[0.27777778],
 [0.44444444],
 [0.33333333]])

P= np.array([100,100,100])

b= 24.44444444

temperatura= a.T.dot(P)+b

print(temperatura)

Ejercicio 1:

y:

Ambas funciones son lineales ya que se cumple en cada una la propiedad de superposici贸n.

Mi soluci贸n:

import numpy as np

A=np.array([[10,10,10,1], [100,10,10,1],[10,100,10,1],[10,10,100,1]])
b = np.array([35, 60,75,65])

a = np.linalg.solve(A,b)

print('solution for b: ', a[3], '\nsolution for all a^T variables: ', a[:3] ) 

Ejercicio 1:

Rpta.: S铆, es lineal.

Ejercicio 2:

Rpta.: S铆, es lineal

Estoy realmente muy contento de decirle que pude resolver el problema. Tard茅 unas horas, pero me ha apasionado resolverlo. Me sirvi贸 mucho retomar otros cursos, fundamentalmente el otro que hay sobre Algebra Lineal donde nos ense帽an a resolver un sistema de ecuaciones lineales usando matrices y vectores. Gracias a este ejercicio termine de entender su utilidad.

Les dejo mi trabajo final:

https://github.com/Mgobeaalcoba/proyectos_platzi/blob/main/Ejercicios_de_Funciones_Lineales.ipynb

Dejo las soluciones en el notebook de mi github, agradezco un star en el github, y un me gusta en este sistema de comentarios, me ayudar铆a bastante.

Buenos d铆as, finalmente pude realizar mi ejercicio gracias a lo que realizaron mis compa帽eros. Los ejercicios no se me hicieron complicados y los hice en mi libreta.

El problema fue lo complicado porque no sab铆a exactamente que ten铆a que hacer hasta que vi los ejercicios de mis compa帽eros y v铆 que ten铆a que resolver un sistema de ecuaciones. En el caso de cual ser铆a la potencia m谩xima no sab铆a como responderlo porque era una ecuaci贸n de 3 incognitas la que estaba manejando, pero despu茅s v铆 que un compa帽ero solo utiliz贸 una y con eso se me facilito el ejercicio.
Anexo una imagen de como resolvi la 煤ltima ecuaci贸n.

Y finalmente anexo mi archivo de Deepnote para que puedan visualizar que es lo que hice en Jupyter Notebook.

Yo solucion茅 el problema 2 con el m茅todo Singular Value Decomposition que les recomiendo bastante investiguen que es bastante 煤til para hacer regresiones etc鈥 La soluci贸n al caso de los tres P al m谩ximo que es 100 da 130 de temperatura y para el ultimo donde se quiere saber los P para que de 150 la temperatura el conjunto de soluciones que encontr茅 esta en la variable sol2 y para poder llegar a 150 se debe superar el m谩ximo de P que nos establece el ejercicio 100.

import numpy as np

A = np.array([
    [10, 10, 10, 1, -35],
    [100, 10, 10, 1, -60],
    [10, 100, 10, 1, -75],
    [10, 10, 100, 1, -65]
])

_, _, V = np.linalg.svd(A)
V = V.transpose()
a = V[:, -1] / V[-1, -1]

# Solucionando el caso donde los tres P son igual a 100
P = 100
sol1 = a[0] * P + a[1] * P + a[2] * P + a[3]


x = np.linspace(100, 150, 400)
y = np.linspace(100, 150, 400)
z = np.linspace(100, 150, 400)

X, Y, Z = np.meshgrid(x, y, z)
error = 150 - (a[0] * X + a[1] * Y + a[2] * Z + a[3])

sol2 = np.where(np.abs(error) < 0.01)
sol2 = np.array([X[sol2],Y[sol2],Z[sol2]])

Resoluci贸n de tercer ejercicio con pasos:

  • Primero planteamos el sistema de ecuaciones

      a0x10+a1x10+a2x10+b=35
      a0x100+a1x10+a2x10+b=60
      a0x10+a1x100+a2x10+b=75
      a0x10+a1x10+a2x100+b=65
    
  • Del planteo anterior podemos sacar la siguiente matriz:

      a0    a1    a2    b
    
      10    10    10    1  | 35
      100   10    10    1  | 60
      10    100   10    1  | 75
      10    10    100   1  | 65
    
  • Para resolver esto podemos emplear el m茅todo Gauss Jord谩n, este nos dice que haciendo operaciones entre las filas de la matriz tenemos que obtener la matriz identidad (una matriz donde su principal diagonal son unos y el resto ceros)

      1  0  0  0 
      0  1  0  0
      0  0  1  0
      0  0  0  1
    
  • Una vez aplicado el m茅todo Gauss Jord谩n nos queda la siguiente matriz:

      a0    a1    a2    b                  a0    a1    a2    b    
      				       |     |     |     |
      1     0     0     0  | 5/18 	       1 ----|-----|----->  | 5/18
      0     1     0     0  | 4/9 	       0 ----1-----|----->  | 4/9
      0     0     1     0  | 1/3 	       0     0     1----->  | 1/3
      0     0     0     1  | 220/9 	       0     0     0     1->| 220/9
    
  • Es con esto que nos quedan los escalares que vana a acompa帽ar a cada uno de los valores de la ecuaci贸n. Ahora toca ver que los valores sean correctos, remplazando tenemos que:

      (5/18)x10+(4/9)x10+(1/3)x10+(220/9)=35
      (5/18)x100+(4/9)x10+(1/3)x10+(220/9)=60
      (5/18)x10+(4/9)x100+(1/3)x10+(220/9)=75
      (5/18)x10+(4/9)x10+(1/3)x100+(220/9)=65
    

Mi soluci贸n a la pregunta sobre la temperatura que alcanzar谩 el cluster si los procesadores trabajan a 100 de potencia.

Comparto mi soluci贸n, Yo lo realice por medio del metodo de Gauss planteando una matriz que se adecuara al problema, escalonandola y sacando los valores de dichas variables

Si observas las variables de esta forma es sencillo llegar a la soluci贸n, me encanto esta clase 鈾

Para solucionar el problema:

pt = np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]])
t = np.array([35,60,75,65])
pt_inv = np.linalg.inv(pt.T)   # matriz inversa que pasa al otro lado
a_vec = t.dot(pt_inv)  # se calculan los coeficientes
print(a_vec) 

[ 0.27777778 0.44444444 0.33333333 24.44444444]

Procesadores a m谩x. potencia

y = a_vec.dot(np.array([100,  100,  100, 1]))

129.99
coeficientes para llegar a 150:

(150 - (1*a_vec[3]))/ sum(a_vec[0:3])

118.94

y = a_vec.dot(np.array([118.94,   118.94,   118.94, 1]))

149.99

Bas谩ndome en algunas soluciones de los compa帽eros, esta es la m铆a para encontrar el m谩ximo sin sobrepasar la temperatura de 150

#Potencia maxima para que T <= 150

#Generando los vectores
rrr = np.array([10,10,10,1])
mrr = np.array([100,10,10,1])
rmr = np.array([10,100,10,1])
rrm = np.array([10,10,100,1])

#Generando la matriz a partir de los vectores
matriz = np.array([rrr, mrr, rmr, rrm])

#Generando el vector de temperaturas
temp = np.array([35, 60, 75, 65])

#Usando la funcion np.linalg.solve() para resolver el sistema de ecuaciones
solu = np.linalg.solve(matriz, temp)

#Obtenemos b
b = solu[3]

#Obtenemos los coeficientes
coef1 = solu[0]
coef2 = solu[1]
coef3 = solu[2]

#Partimos en 0 todos los valores
x = 0
y = 0
z = 0
max = 0

#Obtenemos todos los valores max, x, y, z
max_values = []
x_values = []
y_values = []
z_values = []

#Ciclo while para obtener el m谩ximo a partir del sistema de ecuaciones resuelto
while max < 150:
  max = coef1*x + coef2*y + coef3*z + b
  max_values.append(max)
  x_values.append(x)
  y_values.append(y)
  z_values.append(z)

#Vamos sumando x, y, z de poco en poco para obtener un valor mas cercano a 150
  x += 0.1
  y += 0.1
  z += 0.1

#Imprimimos los valores x, y, z, como vectores, y max como la temperatura m谩xima.
#Sabiendo que max siempre sera mayor a 150 para romper el ciclo while.
#Accedemos al valor penultimo de los valores.
max_vector = [round(x_values[len(x_values)-2], 4), round(y_values[len(y_values)-2], 4), round(z_values[len(z_values)-2], 4)]
print(max_vector, ' = ', round(max_values[len(max_values)-2], 4))

Mi aporte con la soluci贸n del reto. Para el primer ejercicio realic茅 una funci贸n que verifica si una funci贸n (vaya la redundancia) es lineal o no. Esto lo hace comprobando el principio de superposici贸n.

import random
import numpy as np

def f1(x):
    return x[-1]-x[0]

def f2(x):
    return x[3]+(x[3]-x[2])

def check_linear(f, n):
    """
    Check if a function f is linear by verifying the superposition principle.
    """
    a = random.randint(-n**2, n**2)
    b = random.randint(-n**2, n**2)
    x = np.array([])
    y = np.array([])
    for _ in range(n):
        x = np.append(x, random.randint(-n**2, n**2))
        y = np.append(y, random.randint(-n**2, n**2))
    if f(a*x+b*y) == a*f(x)+b*f(y):
        return "Linear function"
    else:
        return "Non-linear function"

# number of dimensions
n = 5
print("f(x) = x_n-1 - x_0 -> ", check_linear(f1, n))
print("f(x) = x_3 + (x_3 - x_2) ->", check_linear(f2, n))

Output:

f(x) = x_n-1 - x_0 ->  Linear function
f(x) = x_3 + (x_3 - x_2) -> Linear function

Para el segundo ejercicio opt茅 por resolver el sistema de ecuaciones construido a partir de los datos emp铆ricos.


Obteniendo la temperatura a potencia m谩xima:

Calculando la potencia m谩xima para la temperatura de fusi贸n. En este caso se obtiene una expresi贸n como resultado ya que la potencia m谩xima permitida de cada procesador depender谩 de la potencia de los dos procesadores restantes.

Mis resultados son:
a_0 = 5/18
a_1 = 4/9
a_2 = 1/3
b = 220/9
Con estos valores f((100, 100, 100)) = 130, luego no se alcanza la temperatura de peligro para los procesadores.

Ejecicio
1.-

def h(x):
  return x[3] - x[0]

x = np.array([1,-1,1,1])
y = np.array([-1,1,1,1])
a,b = 1/2, 1/2
if h(x*a + y*b) == a*h(x) + b*h(y): 
  print('la funci贸n g es lineal')
else: 
  print('la funci贸n g no es lineal')

la funci贸n g es lineal
2.-

def j(x):
  return 2*x[3] - x[2]

if j(x*a + y*b) == a*j(x) + b*j(y): 
  print('la funcion g es lineal')
else: 
  print('la funcion g no es lineal')

la funcion g es lineal

Problema

def T(P):
  return np.array([5/18,4/9,1/3])@P + 220/9

p1 = np.array([10,10,10])
p2 = np.array([100,10,10])
p3 = np.array([10,100,10])
p4 = np.array([10,10,100])

print(T(p1))
print(T(p2))
print(T(p3))
print(T(p4))

35.0
60.0
75.0
65.0

P <= 118 para que T <= 150

Les dejo el enlace y capturas de mi soluci贸n:

Duda! Se podr铆a tomar la funci贸n primera como funci贸n objetivo y la otra como una restricci贸n y 驴resolver en alg煤n punto derivando e igualando a 0 por Langrange?. Nada se me ocurre resolverlo de esa manera, pero las funciones no est谩n muy claras jejeje

primer ejercicio:

import numpy as np
def superposicion(x,y,a,b):
    print('f(x*a + y*b) = ',f(x*a + y*b))
    print('x*f(a) + y*f(b) =',x*f(a) + y*f(b))

def f(x):
    return x[-1-1]-x[0]

a=np.array([1,5,-4])
b=np.array([2,2,-1])
x,y=2,-4

superposicion(x,y,a,b)

output:

Si es lineal.

Segundo ejercicio:

import numpy as np
def superposicion(x,y,a,b):
    print('f(x*a + y*b) = ',g(x*a + y*b))
    print('x*f(a) + y*f(b) =',x*g(a) + y*g(b))

def g(x):
    return x[3]+(x[3]-x[2])

a=np.array([1,5,-4,2])
b=np.array([2,2,-1,-7])
x,y=2,-4

superposicion(x,y,a,b)

Output:

tambi茅n es lineal
Aun estoy terminand el ultimo problema

Les comparto mi soluci贸n

# %% [markdown]
# ## Ejercicio: Determina si las siguientes funciones son lineales o no
# %% [markdown]
# * $f(\mathbf{x}) = x_{n-1} - x_{0}$
# 
# * Si $\mathbf{x}\in\mathbb{R}^{4}$ y $f:\mathbb{R}^{4} \to \mathbb{R}$ definida como $f(\mathbf{x})=x_{3}+(x_{3}-x_{2})$

# %%
x = np.random.rand(np.random.randint(100))
y = np.random.rand(x.size)
a = 10
b = 42

def f1(vector):
    return vector[-1] - vector[0]


# %%
print('Function(a*x + b*y) = ', f1(a*x + b*y))
print('a*Function(x) + b*Function(y) = ', a*f1(x) + b*f1(y))
# La funci贸n es lineal


# %%
x = np.random.rand(4)
y = np.random.rand(4)
a = np.random.randint(100)
b = np.random.randint(100)

def f2(vector):
    return vector[2] + (vector[2]-vector[1])


# %%
print('Function(a*x + b*y) = ', f2(a*x + b*y))
print('a*Function(x) + b*Function(y) = ', a*f2(x) + b*f2(y))
# La funci贸n es lineal


# %%


# %% [markdown]
# ## Problema: Potencia en un cl煤ster de procesadores y temperatura

# %%
# Datos
P1 = np.array([10,10,10])
P2 = np.array([100,10,10])
P3 = np.array([10,100,10])
P4 = np.array([10,10,100])
T1 = 35
T2 = 60
T3 = 75
T4 = 65


# %%
# Sitema de ecuaciones lineales mediante matrices
# P matriz de coeficientes, 3 primeros n煤meros vector a y ultimo n煤mero valor del bias b

P = np.array(
[[10, 10, 10, 1],
[100,10,10, 1],
[10,100,10, 1],
[10, 10, 100, 1]])
T = np.array([T1, T2,T3, T4])


# %%
a = np.linalg.solve(P,T)[0:3]
b = np.linalg.solve(P,T)[3]
a, b
# (array([0.27777778, 0.44444444, 0.33333333]), 24.444444444444443)


# %%
def temperature(P):
    return [email protected]+b
T1_solution = temperature(P1)
T2_solution = temperature(P2)
T3_solution = temperature(P3)
T4_solution = temperature(P4)

T_solution = np.array((T1_solution,T2_solution,T3_solution,T4_solution))
T_solution
# array([35., 60., 75., 65.])


# %%
# Soluci贸n mediante lstsq
np.linalg.lstsq(P,T,rcond=None)[0]
# array([ 0.27777778,  0.44444444,  0.33333333, 24.44444444])

# %% [markdown]
# * Temperatura m谩xima

# %%
# Temperatura a m谩xima potencia
T_m谩xima = temperature([100,100,100])
T_m谩xima
# 130.0


# %%
# La temperatua m谩xima que se puede alcanzar es de 130

# %% [markdown]
# * Potencia para que los procesadores alcancen una temperatura de 150

# %%
from sklearn.linear_model import LinearRegression
model = LinearRegression()


# %%
T = T.reshape(-1,1)


# %%
model.fit(T,P)


# %%
print("coeff: ", *model.coef_)
print("intercept: ", model.intercept_)
# coeff:  [0.1294964] [1.68345324] [0.64748201] [0.]
# intercept:  [ 24.89208633 -66.4028777   -5.53956835   1.        ]

# Pares x + b, para cada una de las 4 salidas


# %%
P_150 = model.predict([[150]])[0][:-1]
P_150 
# array([ 44.31654676, 186.11510791,  91.58273381])


# %%
# Comprobaci贸n de temperatura con el vector de la potencia encontrada de los procesadores
T_150 = temperature(P_150)
T_150

# %% [markdown]
# * 驴Cu谩l es la potencia minima para alcanzar 150 de Temperatura?

# %%
P = 100
T = temperature([P,P,P])

while (T < 150):
    tol = 0.0001
    P += tol
    T = temperature([P,P,P])
print(P,T)
# 118.94740000062899 150.00003333399727

Aqu铆 mi respuesta al Problema Final , intent茅 ser lo m谩s espec铆fico posible y detallado en los t茅rminos matem谩ticos.

La temperatura alcanzada es 130

import numpy as np

s = np.array([[10, 10, 10, 1], [100, 10, 10, 1], [10, 100, 10, 1], [10, 10, 100, 1]])
T = np.array([[35], [60], [75], [65]])

a = (np.linalg.inv(s)).dot(T)
b = float(a[3][0])
c = a[:][:3]
p = np.array([[100,100,100]])
T_full = (c.T).dot(p.T) + b
print(T_full)	 

Lo tengo resuelto en papel, pueden copiar y pegar el enlace. Espero les sirva.
https://drive.google.com/file/d/1yH9ZxKPXpmELnzbZEB_9iXt04RrReoV1/view?usp=sharing

Hoy aprend铆 a utilizar la funci贸n np.linalg a partir de los aportes y not茅 que da una aproximaci贸n bastante considerable respecto los resultados dados.
Para comprobarlo de otra forma, fui a una calculadora en l铆nea e ingrese la matriz para resolver de la forma escalonada reducida por filas, el resultado fue Po=5/18 P1=4/9 P2=1/3 b=220/9
Con esos coeficientes nos regresa los resultados exactos y la temperatura cuando se trabaja a m谩xima potencia es de 130

Quizas estoy entendiendo mal, pero la primera soluci贸n q se me vino a la mente es esta:
reposo = [10,10,10] #35
primer_pro = [100,10,10] #60 #25
segun_pro = [10,100,10] #75 #40
tercer_pro = [10,10,100] #65 #30
(la segunda columna es la diferencia entre el reposo (35) y la temperatura q levant贸
25+40+30+35 = 130 #maxima potencia
Hay algun error en esto?

def a(x): # por que me da flojera escribir...
    return np.array(x)
independientes=a([35,60,75,65])
matriz=a([[10,10,10,1],
        [100,10,10,1],
        [10,100,10,1],
        [10,10,100,1]])

soln=np.linalg.solve(mat, independientes)
print(soln,"temp max: ",100*soln[:-1].sum()+soln[-1])```