initialize

Author: Kundan1804

DL/pract1.ipynb

@@ -0,0 +1,132 @@
+import io
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+%matplotlib inline
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from sklearn.metrics import mean_absolute_error, r2_score
+import warnings
+warnings.filterwarnings('ignore')
+
+# Importing DataSet and take a look at Data
+data = pd.read_csv('housing_data - housing_data.csv')
+data
+
+# Handle null values by filling them with the mean of the respective columns
+data.fillna(data.mean(), inplace=True)
+
+data.isnull().sum()
+
+data.describe()
+
+data.info()
+data.shape
+
+import seaborn as sns
+sns.distplot(data.MEDV)
+
+sns.boxplot(data.MEDV)
+
+correlation = data.corr()
+correlation.loc['MEDV']
+
+# plotting the heatmap
+import matplotlib.pyplot as plt
+fig,axes = plt.subplots(figsize=(15,12))
+sns.heatmap(correlation,square = True,annot = True)
+
+# Checking the scatter plot with the most correlated features
+plt.figure(figsize = (20,5))
+features = ['LSTAT','RM','PTRATIO']
+for i, col in enumerate(features):
+  plt.subplot(1, len(features) , i+1)
+  x = data[col]
+  y = data.MEDV
+  plt.scatter(x, y, marker='o')
+  plt.title("Variation in House prices")
+  plt.xlabel(col)
+  plt.ylabel('"House prices in $1000"')
+
+# Splitting the dependent feature and independent feature
+#X = data[['LSTAT','RM','PTRATIO']]
+X = data.iloc[:,:-1]
+y= data.MEDV
+
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+# Assuming you have data stored in some variables X and y
+# Splitting data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+# Now you can proceed with the code you provided
+# Importing necessary libraries
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import StandardScaler
+# Scaling the features
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+mean = X_train.mean(axis=0)
+std = X_train.std(axis=0)
+X_train = (X_train - mean) / std
+X_test = (X_test - mean) / std
+#Linear Regression
+
+from sklearn.linear_model import LinearRegression
+regressor = LinearRegression()
+#Fitting the model
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+regressor.fit(X_train,y_train)
+
+
+
+#Prediction on the test dataset
+y_pred = regressor.predict(X_test)
+# Predicting RMSE the Test set results
+from sklearn.metrics import mean_squared_error
+rmse = (np.sqrt(mean_squared_error(y_test, y_pred)))
+print(rmse)
+
+from sklearn.metrics import r2_score
+r2 = r2_score(y_test, y_pred)
+print(r2)
+
+from sklearn.metrics import r2_score
+r2 = r2_score(y_test, y_pred)
+print(r2)
+
+#Evaluation of the model
+y_pred = model.predict(X_test)
+mse_nn, mae_nn = model.evaluate(X_test, y_test)
+print('Mean squared error on test data: ', mse_nn)
+print('Mean absolute error on test data: ', mae_nn)
+
+#Comparison with traditional approaches
+#First let's try with a simple algorithm, the Linear Regression:
+from sklearn.metrics import mean_absolute_error
+lr_model = LinearRegression()
+lr_model.fit(X_train, y_train)
+y_pred_lr = lr_model.predict(X_test)
+mse_lr = mean_squared_error(y_test, y_pred_lr)
+mae_lr = mean_absolute_error(y_test, y_pred_lr)
+print('Mean squared error on test data: ', mse_lr)
+print('Mean absolute error on test data: ', mae_lr)
+from sklearn.metrics import r2_score
+r2 = r2_score(y_test, y_pred)
+print(r2)
+
+# Predicting RMSE the Test set results
+from sklearn.metrics import mean_squared_error
+rmse = (np.sqrt(mean_squared_error(y_test, y_pred)))
+print(rmse)
+
+# Make predictions on new data
+import sklearn
+new_data = scaler.transform([[0.1, 10.0, 5.0, 0, 0.4, 6.0, 50, 6.0, 1, 400, 20, 300, 10]])  # Scaling new data
+prediction = model.predict(new_data)
+print("Predicted house price:", prediction)

DL/pract1.txt

@@ -0,0 +1,97 @@
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from tensorflow import keras
+import numpy as np
+
+(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
+
+
+plt.imshow(x_train[1])
+
+# Next, we will preprocess the data by scaling the pixel values to be between 0 and 1, and then reshaping the images to be 28x28 pixels.
+x_train = x_train.astype('float32') / 255.0
+x_test = x_test.astype('float32') / 255.0
+x_train = x_train.reshape(-1, 28, 28, 1)
+x_test = x_test.reshape(-1, 28, 28, 1)
+# 28, 28 comes from width, height, 1 comes from the number of channels
+# -1 means that the length in that dimension is inferred.
+# This is done based on the constraint that the number of elements in an ndarray or Tensor when reshaped must remain the same.
+# each image is a row vector (784 elements) and there are lots of such rows (let it be n, so there are 784n elements). So TensorFlow can infer that -1 is n.
+
+x_train.shape
+x_test.shape
+y_train.shape
+y_test.shape
+
+# We will use a convolutional neural network (CNN) to classify the fashion items.
+# The CNN will consist of multiple convolutional layers followed by max pooling,
+# dropout, and dense layers. Here is the code for the model:
+
+model = keras.Sequential([
+    keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
+    # 32 filters (default), randomly initialized
+    # 3*3 is Size of Filter
+    # 28,28,1 size of Input Image
+    # No zero-padding: every output 2 pixels less in every dimension
+    # in Paramter shwon 320 is value of weights: (3x3 filter weights + 32 bias) * 32 filters
+    # 32*3*3=288(Total)+32(bias)= 320
+
+
+    keras.layers.MaxPooling2D((2,2)),
+    # It shown 13 * 13 size image with 32 channel or filter or depth.
+
+    keras.layers.Dropout(0.25),
+    # Reduce Overfitting of Training sample drop out 25% Neuron
+
+    keras.layers.Conv2D(64, (3,3), activation='relu'),
+    # Deeper layers use 64 filters
+    # 3*3 is Size of Filter
+    # Observe how the input image on 28x28x1 is transformed to a 3x3x64 feature map
+    # 13(Size)-3(Filter Size )+1(bias)=11 Size for Width and Height with 64 Depth or filtter or channel
+    # in Paramter shwon 18496 is value of weights: (3x3 filter weights + 64 bias) * 64 filters
+    # 64*3*3=576+1=577*32 + 32(bias)=18496
+
+    keras.layers.MaxPooling2D((2,2)),
+    # It shown 5 * 5 size image with 64 channel or filter or depth.
+
+    keras.layers.Dropout(0.25),
+
+    keras.layers.Conv2D(128, (3,3), activation='relu'),
+    # Deeper layers use 128 filters
+    # 3*3 is Size of Filter
+    # Observe how the input image on 28x28x1 is transformed to a 3x3x128 feature map
+    # It show 5(Size)-3(Filter Size )+1(bias)=3 Size for Width and Height with 64 Depth or filtter or channel
+    # 128*3*3=1152+1=1153*64 + 64(bias)= 73856
+
+    # To classify the images, we still need a Dense and Softmax layer.
+    # We need to flatten the 3x3x128 feature map to a vector of size 1152
+    # https://medium.com/@iamvarman/how-to-calculate-the-number-of-parameters-in-the-cnn-5bd55364d7ca
+
+    keras.layers.Flatten(),
+    keras.layers.Dense(128, activation='relu'),
+    # 128 Size of Node in Dense Layer
+    # 1152*128 = 147584
+
+    keras.layers.Dropout(0.25),
+    keras.layers.Dense(10, activation='softmax')
+    # 10 Size of Node another Dense Layer
+    # 128*10+10 bias= 1290
+])
+
+model.summary()
+
+# Compile and Train the Model
+# After defining the model, we will compile it and train it on the training data.
+
+model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+
+history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))
+
+# 1875 is a number of batches. By default batches contain 32 samles.60000 / 32 = 1875
+
+
+# Finally, we will evaluate the performance of the model on the test data.
+
+test_loss, test_acc = model.evaluate(x_test, y_test)
+
+print('Test accuracy:', test_acc)