ML-Notes - Revision history

SkyPanther: /* Loss Functions */

2025-01-29T03:40:11Z

Loss Functions

← Older revision		Revision as of 03:40, 29 January 2025
Line 121:		Line 121:

	loss.backward()		loss.backward()
			----👉 '''Loss''' is a measure of how far off the model’s prediction is from the '''ground truth (actual value)''' in the training set.

			👉 The '''loss function''' mathematically quantifies this difference, producing a numerical value that represents the error.

			👉 The '''goal of training''' is to minimize this loss by adjusting the model’s parameters (weights) using '''backpropagation and optimization algorithms''' (e.g., Adam, SGD).

			So in simple terms:

			'''“Loss = Difference between actual value and predicted output, measured by a specific function.”'''

	== Optimizer ==		== Optimizer ==

SkyPanther at 23:37, 11 January 2025

2025-01-11T23:37:56Z

@@ Line 111: / Line 111: @@
 BCELoss does not have the sigmoid activation function, while BCEWithLogitsLoss combines the sigmoid activation.  BCEWithLogitsLoss is more stable, because it has one layer, instead of first doing BCELoss, then Sigmoid in a different layer.
 == Optimizer ==
@@ Line 116: / Line 126: @@
 Use Adam Optimizer for '''Classification''', '''Regression''' and others <code>torch.optim.AdamW().</code>
 == Logits ==

SkyPanther: /* Hardware Agnostic Code */

2025-01-03T21:07:47Z

Hardware Agnostic Code

← Older revision		Revision as of 21:07, 3 January 2025
Line 5:		Line 5:
	If using numpy plot data, you may run into device issues, as numpy uses cpu to do calculation. To fix this, cast the Tensor to cpu device, with .cpu(), e.g.:		If using numpy plot data, you may run into device issues, as numpy uses cpu to do calculation. To fix this, cast the Tensor to cpu device, with .cpu(), e.g.:
	tensor_var.cpu()		tensor_var.cpu()



	When going from numpy to tensors, will have to use .'''from_numpy'''(x), this is usually done when importing from skikit-learn e.g:		When going from numpy to tensors, will have to use .'''from_numpy'''(x), this is usually done when importing from skikit-learn e.g:


	~~```html~~
	<pre>		<pre>
	# Import necessary libraries		# Import necessary libraries

SkyPanther: /* Hardware Agnostic Code */

2025-01-03T21:07:26Z

Hardware Agnostic Code

← Older revision		Revision as of 21:07, 3 January 2025
Line 9:		Line 9:
	When going from numpy to tensors, will have to use .'''from_numpy'''(x), this is usually done when importing from skikit-learn e.g:		When going from numpy to tensors, will have to use .'''from_numpy'''(x), this is usually done when importing from skikit-learn e.g:


			```html
			<pre>
			# Import necessary libraries
	import sklearn		import sklearn

	from sklearn.datasets import make_circles		from sklearn.datasets import make_circles

	from sklearn.model_selection import train_test_split		from sklearn.model_selection import train_test_split
			import torch # Ensure PyTorch is imported for tensor operations

			# Define the number of samples
	n_samples = 1000		n_samples = 1000

	X, y = make_circles(n_samples,		# Generate a synthetic dataset of circles
			X, y = make_circles(n_samples=n_samples, # Total number of samples
			noise=0.03, # Add slight noise to the data
			random_state=42) # Ensures reproducibility

	~~noise~~=0.~~03,~~		# Convert the dataset to PyTorch tensors
			X = torch.from_numpy(X).type(torch.float)

	~~random_state~~ = ~~42)~~		# Split the dataset into training and testing sets
			X_train, X_test, y_train, y_test = train_test_split(
	X = ~~torch~~.~~from_numpy(X).type(torch.float~~)		X, y, # Features and labels
			test_size=0.2, # 20% of data will be used for testing
			random_state=42 # Ensures reproducibility of the split
			)

	X_train, X_test, y_train, y_test ~~= train_test_split(X, y, test_size = 0~~.~~2,random_state = 42~~)		# Output shapes for verification
			print(f"Training features shape: {X_train.shape}")
			print(f"Testing features shape: {X_test.shape}")
			print(f"Training labels shape: {y_train.shape}")
			print(f"Testing labels shape: {y_test.shape}")
			</pre>

	== Creating Valid Data ==		== Creating Valid Data ==

SkyPanther at 21:04, 3 January 2025

2025-01-03T21:04:01Z

@@ Line 2: / Line 2: @@
 This will run the model in the hardware that your system has aviable to it. Defaulting to CPU if neither Apple Silicon (mps), NVIDIA CUDA (cuda) or AMD Radeon Open Compute is found on the system.
   device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "hip" if torch.backends.hip.is_available() else "cpu"
 If using numpy plot data, you may run into device issues, as numpy uses cpu to do calculation. To fix this, cast the Tensor to cpu device, with .cpu(), e.g.:
   tensor_var.cpu()
 == Creating Valid Data ==

SkyPanther: /* Hardware Agnostic Code */

2025-01-03T20:41:14Z

Hardware Agnostic Code

← Older revision		Revision as of 20:41, 3 January 2025
Line 2:		Line 2:
	This will run the model in the hardware that your system has aviable to it. Defaulting to CPU if neither Apple Silicon (mps), NVIDIA CUDA (cuda) or AMD Radeon Open Compute is found on the system.		This will run the model in the hardware that your system has aviable to it. Defaulting to CPU if neither Apple Silicon (mps), NVIDIA CUDA (cuda) or AMD Radeon Open Compute is found on the system.
	device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "hip" if torch.backends.hip.is_available() else "cpu"		device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "hip" if torch.backends.hip.is_available() else "cpu"


			If using numpy plot data, you may run into device issues, as numpy uses cpu to do calculation. To fix this, cast the Tensor to cpu device, with .cpu(), e.g.:
			tensor_var.cpu()

	== Creating Valid Data ==		== Creating Valid Data ==

SkyPanther: /* 2. Logistic Regression */

2025-01-03T17:27:56Z

2. Logistic Regression

← Older revision		Revision as of 17:27, 3 January 2025
Line 119:		Line 119:
	* '''Optimizer''': <code>torch.optim.SGD</code> or <code>torch.optim.AdamW</code>		* '''Optimizer''': <code>torch.optim.SGD</code> or <code>torch.optim.AdamW</code>
	* '''Loss Function''':		* '''Loss Function''':
			** <code>torch.nn.BCELoss</code>
			*** Does not apply sigmoid, or round, has to be done manually. (Not recommended for modern models)
	** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)		** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)
	*** Internally applies a sigmoid before computing binary cross-entropy, offering better numerical stability.		*** Internally applies a sigmoid before computing binary cross-entropy, offering better numerical stability.

SkyPanther: /* 2. Logistic Regression */

2025-01-03T17:25:46Z

2. Logistic Regression

← Older revision		Revision as of 17:25, 3 January 2025
Line 120:		Line 120:
	* '''Loss Function''':		* '''Loss Function''':
	** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)		** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)
	** Internally applies a sigmoid before computing binary cross-entropy, offering better numerical stability.		*** Internally applies a sigmoid before computing binary cross-entropy, offering better numerical stability.
	** <code>torch.nn.CrossEntropyLoss</code> (for multi-class classification)		** <code>torch.nn.CrossEntropyLoss</code> (for multi-class classification)

SkyPanther: /* 2. Logistic Regression */

2025-01-03T17:25:24Z

2. Logistic Regression

← Older revision		Revision as of 17:25, 3 January 2025
Line 117:		Line 117:

	* '''Use Case''': Predicting binary or categorical outcomes, such as determining whether an email is spam or not.		* '''Use Case''': Predicting binary or categorical outcomes, such as determining whether an email is spam or not.
	* '''Optimizer''': <code>torch.optim.SGD</code> or <code>torch.optim.~~Adam~~</code>		* '''Optimizer''': <code>torch.optim.SGD</code> or <code>torch.optim.AdamW</code>
	* '''Loss Function''':		* '''Loss Function''':
	** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)		** <code>torch.nn.BCEWithLogitsLoss</code> (Recommended for binary classification)

SkyPanther: /* Setting the Algorithm */

2025-01-03T17:24:27Z

Setting the Algorithm

← Older revision		Revision as of 17:24, 3 January 2025
Line 24:		Line 24:

	== Setting the Algorithm ==		== Setting the Algorithm ==
	~~This particular problem uses the~~ Linear Regression algorithm, ~~which is rendered like this in code~~:		The Linear Regression algorithm is used for regression problems, for instance, creating a line for house price vs square footage, or house price and state the simplified representation of the linear relationship between X (the feature or input) and y (the target or output) using the linear regression equation:
	y = weight * X + bias		y = weight * X + bias

	== Creating Training/Testing Split ==		== Creating Training/Testing Split ==
	Normally, when training split the data 80/20. 80 for training, and 20 for testing.		Normally, when training, split the data 80/20. 80 for training, and 20 for testing.

	Something like:		Something like:
Line 54:		Line 54:

	self.bias = nn.Parameter(torch.randn(1, requires_grad=True,dtype=torch.float)) # creates a models parameter, using random		self.bias = nn.Parameter(torch.randn(1, requires_grad=True,dtype=torch.float)) # creates a models parameter, using random
	def forward(self, x: torch.Tensor) -> torch.Tensor: # REQUIRED: Forward method is required for all nn.Module subclasses, it needs to ~~overide~~ the forward method in the nn.Module class		def forward(self, x: torch.Tensor) -> torch.Tensor: # REQUIRED: Forward method is required for all nn.Module subclasses, it needs to override the forward method in the nn.Module class

	return self.weights * x + self.bias		return self.weights * x + self.bias (the Linear Regression)

	Inside that you will need to initialize the the weights and biases, usually to random or zero, and set the forward loop. The forward loop is required.		Inside that you will need to initialize the the weights and biases, usually to random or zero, and set the forward loop. The forward loop is required.
Line 69:		Line 69:
	For '''regression''', you will want to use MAE <code>nn.L1Loss()</code>, or MSE <code>nn.MSELoss().</code>		For '''regression''', you will want to use MAE <code>nn.L1Loss()</code>, or MSE <code>nn.MSELoss().</code>

	For '''classification''', you might want to use binary cross entropy<code>nn.BCELoss() or nn.BCEWithLogitsLoss() ((recommended)</code>, or categorical cross entropy<code>nn.CrossEntropyLoss()</code>which can also be used for mutli-class classification.		For '''classification''', you might want to use binary cross entropy<code>nn.BCELoss() or nn.BCEWithLogitsLoss() (recommended)</code>, or categorical cross entropy<code>nn.CrossEntropyLoss()</code>which can also be used for mutli-class classification.

	BCELoss does not have the sigmoid activation function, while BCEWithLogitsLoss combines the sigmoid activation. ~~However BCEWith...it~~ is more stable, because it has one layer, instead of first doing BCELoss, then Sigmoid in a different layer.		BCELoss does not have the sigmoid activation function, while BCEWithLogitsLoss combines the sigmoid activation. BCEWithLogitsLoss is more stable, because it has one layer, instead of first doing BCELoss, then Sigmoid in a different layer.

	== Optimizer ==		== Optimizer ==
	Use Stochastic Gradient Descent (SDG) Optimizer for '''Classification''', '''Regression''', and others <code>torch.optim.SDG()</code>		Use Stochastic Gradient Descent (SDG) Optimizer for '''Classification''', '''Regression''', and others <code>torch.optim.SDG()</code>

	Use Adam Optimizer for '''Classification''', '''Regression''' and others<code>~~torch.optim.Adam() but~~ torch.optim.AdamW() ~~is recommended~~.</code>		Use Adam Optimizer for '''Classification''', '''Regression''' and others <code>torch.optim.AdamW().</code>

	== Logits ==		== Logits ==
	'''~~Logits~~''' ~~represent~~ the unprocessed outputs directly ~~from the model~~ after a forward pass.		In a machine learning model, '''logits''' are the raw, unprocessed outputs produced directly after a forward pass through the model. These logits are unnormalized values and require further processing to interpret as probabilities or predictions (labels).

	~~When using~~ <code>BCEWithLogitsLoss</code>, the ~~model will output '''raw~~ logits~~''' (unnormalized values) we~~ must ~~convert them into -> prediction probabilities (sigmoid) -> and then into prediction labels (round)~~		===== Using <code>BCEWithLogitsLoss</code> =====
			For binary classification tasks, it is common to use the <code>BCEWithLogitsLoss</code> loss function, which works directly with logits. This eliminates the need to manually apply a sigmoid activation during training, as the loss function internally computes it. However, for inference or evaluation, you must explicitly process the logits to obtain meaningful predictions.

	~~To get this, run~~ the ~~forward pass~~, ~~then~~ torch.sigmoid(), ~~then~~ torch.round() or torch.round(torch.sigmoid()) ~~in full. This is used for binary classification, as the outputs will be 0 or 1.~~		====== Steps to Convert Logits to Predictions ======
			1) '''Convert Logits to Probabilities''': Use the sigmoid activation function to map logits to probabilities in the range [0,1]. This is done as:
			probabilities = torch.sigmoid(logits)
			2) '''Convert Probabilities to Labels''': Apply a threshold (e.g., 0.5) to determine class labels. This can be done using rounding:
			labels = torch.round(probabilities)
			Or, combine the steps:
			labels = torch.round(torch.sigmoid(logits))

	~~Our Model outputs are going~~ to be raw ~~'''~~logits~~'''~~.		=== Example Workflow ===
			1) Perform a forward pass to obtain raw logits:
			logits = model(inputs)
			2) Apply the sigmoid activation to obtain probabilities:
			probabilities = torch.sigmoid(logits)
			3) Round probabilities to get binary class labels (0 or 1):
			labels = torch.round(probabilities)

	~~We can convert these '''logits''' into '''prediction probabilities''' by passing them to some kind of activation function~~		=== General Notes on Activation Functions ===

	~~(e.g. sigmoid for~~ binary classification ~~and softmax for multiclass classification).~~		* For '''binary classification''', use the '''sigmoid''' function, as described above.
			* For '''multi-class classification''', use the '''softmax''' function to convert logits into probabilities across multiple classes.
	~~Then we can convert our model~~'~~s prediction probabilities to~~ '''~~prediction labels~~''' ~~by either rounding them or taking the <code>torch~~.~~argmax()</code>, which is used for~~ '''~~multiclass~~ classification''', ~~taking~~ the ~~index of the maximum probability~~.

	== Types of Learning and their Optimal Algorithms ==		== Types of Learning and their Optimal Algorithms ==