Video "Tech with Tim" sobre módulos✅ de Python

Ejemplos de programas de estas bibliotecas:

1: TensorFlow

Aquí hay un programa de ejemplo simple en TensorFlow para entrenar un modelo para la regresión lineal:

import tensorflow as  tf# Define el modelo model = tf.keras.Sequential([

tf.keras.layers.Dense(
units
=1, input_shape=[1])])# Compilar el modelo con una función de pérdida y un optimizador

model.compile(
loss='mean_squared_error', 

optimizer=tf.keras.optimizers.Adam(0.1))

# Proporcionar datos para entrenar el modelo xs = [1, 2,
3, 4, 5, 6, 7, 8, 9, 10]ys = [1.1, 2.0,   2.9,  4.0
      ,  4.9, 6.0, 6.9, 8.0, 9.1, 10.0]# Entrenar el modelo para 100 épocas model.fit(xs, ys     , epochs=

100
)# Hacer predicciones con el modelo entrenadoprint(model.predict([

7.0
]))

Este programa entrena un modelo para aprender la relación entre una entrada (xs) y una salida (ys) con el objetivo de poder hacer predicciones precisas para entradas no vistas. El modelo consiste en una sola capa densa con una sola unidad, y la función de pérdida de error cuadrático medio y el optimizador de Adam se utilizan para el entrenamiento. El modelo se entrena para 100 épocas en los datos proporcionados, y finalmente, se realiza una predicción para la entrada 7.0.

2: Antorcha PyTorch

Este es un ejemplo sencillo de un programa que utiliza la biblioteca PyTorch para entrenar una red neuronal en el conjunto de datos MNIST:

import torch import torch.nn as
nn import torch.optim  as optim  from
torch.utils.data import DataLoader from torchvision.datasets import MNIST
from   
   
torchvision.transforms import ToTensor# Define la clase de modelo de red neuronal


 NeuralNetwork( nn. Módulo):
 def __init__(self): super
(). __init__()
 self.fc1 = nn. Lineal(28 * 28, 128)
 self.fc2 = nn. Lineal(128, 64)
 self.fc3 = nn. Lineal(64, 10)  def forward(self, x): x = torch.relu(self.fc1(x)) x =

torch.relu(self.fc2(x)) x =  
   self.fc3(x
) return x

# Cargar el conjunto de datos MNIST dataset
= MNIST(root='data/', download=  True, transform=ToTensor())data_loader = DataLoader(dataset,
batch_size=100, shuffle=True)# Inicialice el modelo, la función de pérdida y el modelo optimizador = NeuralNetwork(

)
criterion = nn. CrossEntropyLoss()optimizer = optim. SGD(model.parameters(), lr=0.01)# Entrenar el modelo para 10 épocaspara epoch

en
range(10):  for batch_idx, (data, target) in enumerate
(data_loader): data = data.view(-1  ,  28 * 28) optimizer.zero_grad() output = model(data) loss = criterion(output
,  target) loss.backward() optimizer.step()



 print(f'Epoch {epoch}  - Loss: {loss.item()}')

Este programa entrena una red neuronal feedforward simple con 3 capas totalmente conectadas para clasificar dígitos escritos a mano del conjunto de datos MNIST. La clase NeuralNetwork define la arquitectura del modelo y el bucle de entrenamiento actualiza los parámetros del modelo mediante el optimizador de descenso de gradiente estocástico (SGD).

3: Scikit-aprender

Aquí hay un programa de ejemplo para demostrar el uso de la biblioteca Scikit-learn:

import numpy  as np import
matplotlib.pyplot as plt from sklearn import
datasets from sklearn.model_selection import train_test_splitfrom
sklearn.linear_model  
 import LinearRegression# Cargar el conjunto de datosde  diabetes

 
diabetes = datasets.load_diabetes()

 # Dividir los datos en conjuntos de datos de entrenamiento y pruebas
X_train, X_test, y_train, y_test = train_test_split(diabetes.data  , 

diabetes.target, test_size=0.2, random_state=42)# Entrenar el modelo de regresión lineal reg = LinearRegression().fit(X_train   

,
y_train)# Predecir los valores en el conjunto de datos de prueba y_pred = reg.predict(X_test)# Calcular el error cuadrático medio

mse = np.mean((y_pred - y_test) **
2


)print
( "Error cuadrático medio: ", mse)# Trazar los valores reales y previstos plt.scatter(y_test

,  y_pred)plt.xlabel("Valores reales")plt.ylabel(
"Valores previstos")
plt.show
()

Este programa carga el conjunto de datos de diabetes, divide los datos en conjuntos de datos de entrenamiento y prueba, entrena un modelo de regresión lineal en los datos de entrenamiento, predice los valores objetivo en los datos de prueba y calcula el error cuadrático medio. Finalmente, traza los valores reales y los valores pronosticados para ver qué tan bien está funcionando el modelo.

4: Pandas

Aquí hay un ejemplo del uso de la biblioteca Pandas en Python para analizar y manipular un conjunto de datos:

Importar pandas como PD# Cargar el conjunto de datos en un dataframe pandas df = pd.read_csv

 ('
data.csv')# Imprimir las primeras 5 filas del conjunto de datos print(df.head(5))# Obtener el número de filas y columnas del conjunto de datos print(df.shape

)
# Obtener las estadísticas de resumen de todas las columnas del conjunto de datos

print(
df.describe


())

 # Obtener los valores únicos en una columna específica print(df['column_name'].unique())# Agrupar los datos por una columna específica
y calcular la media de cada grupoagrupado = df.groupby('column_name')print(grouped.mean())#

Ordenar los datos por una columna específica en orden ascendente o descendente
 print(
df.sort_values(


'column_name',  ascending=False))# Filtrar los datos en función de una condición

filtrada = df[df['column_name']
>= valor]print(filtered)
# Reemplazar los valores que faltan en una columna con la media de esa columna media = df['column_name'].mean()

df[
'column_name'].
fillna(mean, inplace=True )

# Colocar una fila o columna específica del conjunto de datos df.drop('
column_name', axis=1, inplace=True)df.drop(index, axis=0  , inplace
=True)# Guardar el conjunto de datos modificado en un nuevo archivo csv

df.to_csv('
modified_data.csv' , index=False)

Este es solo un ejemplo básico de lo que puede hacer con la biblioteca de Pandas. Hay muchas más funciones y características que se pueden utilizar para el análisis y la manipulación de datos.

5: Numpy
Aquí hay un programa simple que demuestra el uso de la biblioteca Numpy:

import numpy  as  np# Define una matriz numpy con forma (3,3) y valores de 0 a 8  array

= np.array([
[0,1,2],[3,4,5],[6,7,8]])print
("Original Array:")
print(array)# Calcular la suma de todos los elementos de la matriz sum_of_elements = np.sum(array)print("Suma de elementos en la matriz: "

,
sum_of_elements)# Calcular la media de todos los elementos de la matriz mean_of_elements
 = np.mean(array)print(

"Media de
los
elementos de la matriz: ", mean_of_elements)

 # Calcular la desviación estándar de todos los elementos de la matriz std_of_elements = np.std(array)print("Desviación estándar de los elementos de la matriz: ",
std_of_elements)
# Encuentre los valores mínimo y máximo en la matriz min_value = np.min(array)max_value = np.max(array)print("Valor mínimo en la matriz: "

,
min_value)

print
( "Valor máximo en la matriz: ", max_value)

Salida

Matriz original:

[[0 1 2]

[3 4 5]

[6 7 8]]

Suma de elementos en la matriz: 36

Media de los elementos de la matriz: 4.0

Desviación estándar de los elementos de la matriz: 2,581988897471611

Valor mínimo en la matriz: 0

Valor máximo en la matriz: 8

6: Matplotlib

Aquí hay un ejemplo de un programa que usa la biblioteca Matplotlib para crear un gráfico de líneas:

Importar matplotlib.pyplot como  plt# Datos para la gráfica x = [1, 2, 3, 4,

5]y
= [2, 4, 1, 5, 3]# Crear la gráfica plt.plot(x       ,  y)

# Agregar etiquetas y título
 

plt.xlabel(
 "X axis")plt.ylabel("Y axis")plt.title(
"Ejemplo de gráfico de líneas")# Mostrar el gráfico
plt.show(

)

Este programa crea un gráfico de líneas utilizando los datos x  e  y, etiqueta el eje x y  el eje y, y agrega un título al gráfico. La  función plt.show() muestra el gráfico en la pantalla.

7: Nacido del mar

Este es un ejemplo del uso de la biblioteca Seaborn para visualizar un conjunto de datos:

import seaborn   as sns import
matplotlib.pyplot as plt# Load the iris dataset

iris = sns.load_dataset('iris'
)# Trazar un histograma de longitud sépalo

sns.histplot(
data=iris, x='sepal_length', bins=30, color=' blue')

# Mostrar la trama
plt.show()

Este código utiliza la biblioteca Seaborn para cargar el dataset del iris y trazar un histograma de la longitud del sépalo con 30 contenedores. El color del histograma se establece en azul. El gráfico resultante se muestra utilizando la biblioteca Matplotlib.

8: Difícil

Aquí hay un ejemplo de un programa simple en Keras que utiliza una red neuronal de alimentación para predecir el número de pasajeros en el Titanic:

import numpy  as np import
pandas as pd from keras.models import Sequential
from keras.layers 
import Dense# Load the Titanic dataset data = pd.read_csv('Titanic.csv')


# Preprocesar los datos data = data.dropna()data = pd.get_dummies(data,

columns
= ['Sexo'])datos = datos[['Pclass', 'Edad', 'SibSp', 'Pergamino', 'Fare'   , 

'Sex_female', 'Sex_male', 'Sobrevivió']]# Dividir los datos en conjuntos de entrenamiento y pruebas train_data = data.iloc[:800, :]test_data = data.iloc[

800:, :]
# Extraer las entradas y salidas train_inputs = train_data.iloc[:, :-1]
.valuestrain_outputs = train_data.iloc[


:, 
- 1].valuestest_inputs = test_data.iloc[:, :-1]
.valuestest_outputs = test_data.iloc[:, -1].values
# Create the model model = Sequential()model.add(Dense(16, input_dim

=
7
   , activation='relu'))model.add(Dense(8
 , activation='relu'))model.add(Dense(1, activation='
sigmoid'))# Compile el modelomodel.compile(loss='binary_crossentropy', optimizer


='adam', 

metrics=['accuracy'])

# Entrenar el modelo model.fit(train_inputs,
train_outputs, epochs=50, batch_size=32)# Evaluar el modelo en la puntuación de datos de prueba= model.evaluate(test_inputs, test_outputs)print("Pérdida de

prueba:"
 
  ,  puntuación[ 0])
print("Precisión de la prueba:", puntuación[1])

9: Scipy

Aquí hay un ejemplo de un programa técnico que usa la biblioteca Scipy en Python:

import numpy as np
from scipy.optimize import minimize

# Define la función objetivo
def objective_func(x):  return  (x[
0] - 1)**2 + (x[1] - 2)**2 + (x[2] - 3)**  2

 # Definir la suposición inicial
  x0 = np.array([0, 0, 0])# Minimizar la función objetivo usando el método Nelder-Mead res = minimize(objective_func

,
x0, method='Nelder-Mead')# Imprimir los valores optimizados print("Valores optimizados: "


,   res.x)
print("Valor mínimo de función objetivo: ", res.fun)

Este programa minimiza la función objetivo objective_func utilizando el método Nelder-Mead del  módulo scipy.optimize. La función objetivo calcula la suma de las diferencias al cuadrado entre los valores de entrada y los valores deseados. La estimación inicial para la optimización se establece en x0,  que es una matriz de ceros. Los valores optimizados y el valor mínimo de la función objetivo se imprimen como resultado.

10: OpenCV

Aquí hay un ejemplo simple del uso de la biblioteca OpenCV para leer y mostrar una imagen en Python:

import cv2# Cargar la imagen img

= cv2.imread("
image.jpg")# Compruebe si la imagen se ha cargado correctamente

si
img es None:  print
("Error: imagen no encontrada". )

# Mostrar la imagen cv2.imshow("
Imagen", img)# Espere a que se presione una tecla cv2.waitKey(

0)
# Destruir todas las ventanascv2.destroyAllWindows()

En este ejemplo, cv2.imread se usa para cargar la imagen, cv2.imshow se usa para mostrar la  imagen,  cv2.waitKey se usa  para esperar una pulsación  de tecla y cv2.destroyAllWindows se usa para cerrar todas las ventanas después de presionar la tecla.

Conclusión

En conclusión, las 10 mejores bibliotecas de Python proporcionan una amplia gama de herramientas y capacidades para satisfacer las diferentes necesidades y requisitos de los desarrolladores. Estas bibliotecas simplifican tareas de programación complejas, optimizan los flujos de trabajo y mejoran la experiencia de desarrollo general. Con la creciente popularidad de Python, las bibliotecas mencionadas en este artículo seguirán siendo componentes esenciales en la creación de soluciones y aplicaciones de vanguardia. Abraza su poder, da rienda suelta a tu creatividad y construye tu próxima gran cosa con Python.

SIÉNTASE LIBRE DE COMPARTIR SU OPINIÓN EN LOS COMENTARIOS