+
+
+## Stanford - Machine Learning - CS229
+Course Description This course provides a broad introduction to machine learning and statistical pattern recognition. Topics include: supervised learning (generative/discriminative learning, parametric/non-parametric learning, neural networks, support vector machines); unsupervised learning (clustering, dimensionality reduction, kernel methods); learning theory (bias/variance tradeoffs, practical advice); reinforcement learning and adaptive control. The course will also discuss recent applications of machine learning, such as to robotic control, data mining, autonomous navigation, bioinformatics, speech recognition, and text and web data processing.
+
+[course website](https://cs229.stanford.edu/)
+
+## Stanford - Natural Language Processing with Deep Learning - CS224n
+
+Natural language processing (NLP) or computational linguistics is one of the most important technologies of the information age. Applications of NLP are everywhere because people communicate almost everything in language: web search, advertising, emails, customer service, language translation, virtual agents, medical reports, politics, etc. In the last decade, deep learning (or neural network) approaches have obtained very high performance across many different NLP tasks, using single end-to-end neural models that do not require traditional, task-specific feature engineering. In this course, students will gain a thorough introduction to cutting-edge research in Deep Learning for NLP. Through lectures, assignments and a final project, students will learn the necessary skills to design, implement, and understand their own neural network models, using the Pytorch framework.
+
+Note: 2019 lectures by Anand Avati are better and have review of concepts for first lectures.
+
+[course website](https://web.stanford.edu/class/cs224n/)
+
+## Stanford - Machine Learning with Graphs - CS224W
+
+Complex data can be represented as a graph of relationships between objects. Such networks are a fundamental tool for modeling social, technological, and biological systems. This course focuses on the computational, algorithmic, and modeling challenges specific to the analysis of massive graphs. By means of studying the underlying graph structure and its features, students are introduced to machine learning techniques and data mining tools apt to reveal insights on a variety of networks.
+Topics include: representation learning and Graph Neural Networks; algorithms for the World Wide Web; reasoning over Knowledge Graphs; influence maximization; disease outbreak detection, social network analysis.
+
+[course website](https://snap.stanford.edu/class/cs224w-2023/index.html#content)
+
+
+## Stanford - Deep Learning for Computer Vision - CS231n
+
+Computer Vision has become ubiquitous in our society, with applications in search, image understanding, apps, mapping, medicine, drones, and self-driving cars. Core to many of these applications are visual recognition tasks such as image classification, localization and detection. Recent developments in neural network (aka “deep learning”) approaches have greatly advanced the performance of these state-of-the-art visual recognition systems. This course is a deep dive into the details of deep learning architectures with a focus on learning end-to-end models for these tasks, particularly image classification. During the 10-week course, students will learn to implement and train their own neural networks and gain a detailed understanding of cutting-edge research in computer vision. Additionally, the final assignment will give them the opportunity to train and apply multi-million parameter networks on real-world vision problems of their choice. Through multiple hands-on assignments and the final course project, students will acquire the toolset for setting up deep learning tasks and practical engineering tricks for training and fine-tuning deep neural networks.
+
+[course website](http://cs231n.stanford.edu/)
+
+## Stanford - Introduction to Statistical Learning - STAT216
+
+Overview of supervised learning, with a focus on regression and classification methods. Syllabus includes: linear and polynomial regression, logistic regression and linear discriminant analysis; cross-validation and the bootstrap, model selection and regularization methods (ridge and lasso); nonlinear models, splines and generalized additive models; tree-based methods, random forests and boosting; support-vector machines; Some unsupervised learning: principal components and clustering (k-means and hierarchical). Computing is done in R, through tutorial sessions and homework assignments. This math-light course is offered via video segments (MOOC style), and in-class problem solving sessions. Prerequisites: first courses in statistics, linear algebra, and computing.
+
+[Tibshirani Course website - 2018](https://tibshirani.su.domains/stats216.html)
+[awesome ISLR course videos](https://www.dataschool.io/15-hours-of-expert-machine-learning-videos/)
+
+## Stanford - Machine Learning Systems Design - CS 329S
+
+This course aims to provide an iterative framework for developing real-world machine learning systems that are deployable, reliable, and scalable.
+
+It starts by considering all stakeholders of each machine learning project and their objectives. Different objectives require different design choices, and this course will discuss the tradeoffs of those choices.
+
+Students will learn about data management, data engineering, feature engineering, approaches to model selection, training, scaling, how to continually monitor and deploy changes to ML systems, as well as the human side of ML projects such as team structure and business metrics. In the process, students will learn about important issues including privacy, fairness, and security.
+
+
+[course website](https://stanford-cs329s.github.io/syllabus.html)
+
+
+
+
+[Overview of AI/ML courses](https://aiml.cs.princeton.edu/course.html)
+
+## Princeton - Computer Vision - COS 429
+
+An introduction to the concepts of 2D and 3D computer vision. Topics include: low-level image processing methods such as filtering and edge detection; segmentation and clustering; optical flow and tracking; recognition; shape reconstruction from stereo, motion, texture, and shading; and recent developments in deep learning. Throughout the course, we also look at aspects of human vision and perception that guide and inspire computer vision techniques.
+
+https://www.cs.princeton.edu/courses/archive/fall19/cos429/
+
+
+
+
+## University of Michigan - Deep Learning for Computer Vision - EECS 498.008 / 598.008
+
+
+Computer Vision has become ubiquitous in our society, with applications in search, image understanding, apps, mapping, medicine, drones, and self-driving cars. Core to many of these applications are visual recognition tasks such as image classification and object detection. Recent developments in neural network approaches have greatly advanced the performance of these state-of-the-art visual recognition systems. This course is a deep dive into details of neural-network based deep learning methods for computer vision. During this course, students will learn to implement, train and debug their own neural networks and gain a detailed understanding of cutting-edge research in computer vision. We will cover learning algorithms, neural network architectures, and practical engineering tricks for training and fine-tuning networks for visual recognition tasks.
+
+Excellent course and essentially an updated version of Stanford CS231n.
+
+[YouTube Playlist](https://www.youtube.com/playlist?list=PL5-TkQAfAZFbzxjBHtzdVCWE0Zbhomg7r)
+
+[Course Website](https://web.eecs.umich.edu/~justincj/teaching/eecs498/WI2022/)
+
+
+
+## UW - Madison - Introduction to Machine Learning and Statistical Pattern Classification - STAT 451
+
+Introduction to machine learning for pattern classification, regression analysis, clustering, and dimensionality reduction. For each category, fundamental algorithms, as well as selections of contemporary, current state-of-the-art algorithms, are being discussed. The evaluation of machine learning models using statistical methods is a particular focus of this course. Statistical pattern classification approaches, including maximum likelihood estimation and Bayesian decision theory, are compared and contrasted to algorithmic and nonparametric approaches. While fundamental mathematical concepts underlying machine learning and pattern classification algorithms are being taught, the practical use of machine learning algorithms using open source libraries from the Python programming ecosystem will be of equal focus in this course.
+
+[course website](https://sebastianraschka.com/teaching/stat451-fs2021/)
+
+[youtube playlist](https://www.youtube.com/playlist?list=PLTKMiZHVd_2KyGirGEvKlniaWeLOHhUF3)
+
+Sebastian also has an excellent textbook [info](https://sebastianraschka.com/blog/2022/ml-pytorch-book.html)
+
+
+
+
+## MIT - Matrix Methods in Data Analysis, Signal Processing, and Machine Learning - MATH 18.065
+
+Linear algebra concepts are key for understanding and creating machine learning algorithms, especially as applied to deep learning and neural networks. This course reviews linear algebra with applications to probability and statistics and optimization–and above all a full explanation of deep learning.
+
+Taught by Gil Strang! - Also 💙 the intro linear algebra course with Strang
+
+[OCW link](https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/)
+
+## MIT - Distributed Systems - CS 6.824
+
+6.824 is a core 12-unit graduate subject with lectures, readings, programming labs, an optional project, a mid-term exam, and a final exam. It will present abstractions and implementation techniques for engineering distributed systems. Major topics include fault tolerance, replication, and consistency. Much of the class consists of studying and discussing case studies of distributed systems.
+
+[course website](https://pdos.csail.mit.edu/6.824/)
+
+## MIT - Introduction to Deep Learning - CS 6.S191
+
+Pretty high level view of DL.
+
+[youtube playlist](https://www.youtube.com/playlist?list=PLtBw6njQRU-rwp5__7C0oIVt26ZgjG9NI)
+
+
+
+## ETH Zurich - Digital Design and Computer Architecture
+
+The class provides a first introduction to the design of digital circuits and computer architecture. It covers technical foundations of how a computing platform is designed from the bottom up. It introduces various execution paradigms, hardware description languages, and principles in digital design and computer architecture. The focus is on fundamental techniques employed in the design of modern microprocessors and their hardware/software interface.
+
+[course website](https://safari.ethz.ch/digitaltechnik/spring2021/doku.php?id=start)
+[YouTube Playlist](https://www.youtube.com/watch?v=LbC0EZY8yw4&list=PL4YhK0pT0ZhXVMJMffEq_XqAIQM_uWSdi)
+
+
+
+## UC Berkely - Advanced Robotics - CS 287
+
+Over the past ten years advances in optimization, in probabilistic reasoning, and in machine learning have had a large impact in robotics, with many of the current state-of-the-art algorithms heavily relying on these tools. At the same time these three tools have wide applicability in many other fields. The current curriculum of CS287 is centered around these three tools---making it both a treatment of these tools (in the context of a specific application domain, namely robotics), as well as a treatment of the state of the art in (algorithmic) robotics. Problem sets are a mix of mathematical/algorithmic questions and programming problems. There is a substantial final project. NOTE: This course is about algorithms for robotics, and does *not* cover hardware aspects. PREREQS: Familiarity with mathematical proofs, probability, algorithms, linear algebra; ability to implement algorithmic ideas in code.
+
+[course website](https://people.eecs.berkeley.edu/~pabbeel/cs287-fa19/)
+
+
+
+## Carnegie Mellon University - MultiModal Machine Learning - 11-777 • Fall 2022
+
+Multimodal machine learning (MMML) is a vibrant multi-disciplinary research field which addresses some of the original goals of artificial intelligence by integrating and modeling multiple communicative modalities, including linguistic, acoustic, and visual messages. With the initial research on audio-visual speech recognition and more recently with language & vision projects such as image and video captioning, this research field brings some unique challenges for multimodal researchers given the heterogeneity of the data and the contingency often found between modalities. This course will teach fundamental mathematical concepts related to MMML including multimodal alignment and fusion, heterogeneous representation learning and multi-stream temporal modeling. We will also review recent papers describing state-of-the-art probabilistic models and computational algorithms for MMML and discuss the current and upcoming challenges.
+
+[course website](https://cmu-multicomp-lab.github.io/mmml-course/fall2022/)
+
+
+
+## University of Washington
+
+Welcome to the Computer Vision course (CSE/ECE 576, Spring 2020)
+
+This class is a general introduction to computer vision. It covers standard techniques in image processing like filtering, edge detection, stereo, flow, etc. (old-school vision), as well as newer, machine-learning based computer vision.
+
+[course website](https://courses.cs.washington.edu/courses/cse576/20sp/)
+
+
+
+## Google Machine Learning Crash Course
+
+Nice quick and easy overview ML topics.
+
+
+[course website](https://developers.google.com/machine-learning/crash-course/ml-intro)
+
+
diff --git a/code/.DS_Store b/code/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..69572ecb84d0e3af00c2310ed2166f16460390ae
Binary files /dev/null and b/code/.DS_Store differ
diff --git a/code/README.md b/code/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..21a1300c8af3c3f86a1164728758ffd3a71b500c
--- /dev/null
+++ b/code/README.md
@@ -0,0 +1,74 @@
+---
+license: apache-2.0
+tags:
+- image-classification
+- generated_from_trainer
+datasets:
+- beans
+metrics:
+- accuracy
+model-index:
+- name: ''
+ results:
+ - task:
+ name: Image Classification
+ type: image-classification
+ dataset:
+ name: beans
+ type: beans
+ args: default
+ metrics:
+ - name: Accuracy
+ type: accuracy
+ value: 0.9774436090225563
+---
+
+
+
+#
+
+This model is a fine-tuned version of [google/vit-base-patch16-224-in21k](https://huggingface.co/google/vit-base-patch16-224-in21k) on the beans dataset.
+It achieves the following results on the evaluation set:
+- Loss: 0.0666
+- Accuracy: 0.9774
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 0.0002
+- train_batch_size: 16
+- eval_batch_size: 8
+- seed: 42
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
+- lr_scheduler_type: linear
+- num_epochs: 4
+
+### Training results
+
+| Training Loss | Epoch | Step | Validation Loss | Accuracy |
+|:-------------:|:-----:|:----:|:---------------:|:--------:|
+| 0.0742 | 1.54 | 100 | 0.0806 | 0.9774 |
+| 0.0185 | 3.08 | 200 | 0.0666 | 0.9774 |
+
+
+### Framework versions
+
+- Transformers 4.14.1
+- Pytorch 1.10.0
+- Datasets 2.0.0
+- Tokenizers 0.10.3
diff --git a/code/activation_functions.md b/code/activation_functions.md
new file mode 100644
index 0000000000000000000000000000000000000000..4d2293d3a5e87bb63114f8a93bb4290774181eb6
--- /dev/null
+++ b/code/activation_functions.md
@@ -0,0 +1,45 @@
+https://stats.stackexchange.com/questions/11859/what-is-the-difference-between-multiclass-and-multilabel-problem
+
+https://machinelearningmastery.com/choose-an-activation-function-for-deep-learning/
+
+https://web.stanford.edu/~nanbhas/blog/sigmoid-softmax/
+
+
+Binary Classification: One node, sigmoid activation.
+Multiclass Classification: One node per class, softmax activation.
+Multilabel Classification: One node per class, sigmoid activation.
+
+Multi-class vs Binary-class is the question of the number of classes your classifier is modeling. In theory, a binary classifier is much simpler than multi-class, so it's important to make this distinction. For example, the Support vector machine (SVM) can trivially learn a hyperplane to separate two classes, but 3 or more classes makes it complex. In the neural networks, we commonly use Sigmoid for binary, but Softmax for multi-class as the last layer of the model.
+
+Multi-label vs Single-Label is the question of how many classes any object or example can belong to. In the neural networks, if single label is needed we use a single Softmax layer as the last layer, thus learning a single probability distribution that spans across all classes. If the multi-label classification is needed, we use multiple Sigmoids on the last layer, thus learning separate distribution for each class.
+
+# Cross-Entropy or Log Likelihood in Output Layer (StackExchange)
+
+*negative log likelihood* is also known as multi class cross-entropy
+
+
+### all of the normal loss functions and their applications in PyTorch
+
+https://neptune.ai/blog/pytorch-loss-functions
+
+
+https://medium.com/deeplearningmadeeasy/negative-log-likelihood-6bd79b55d8b6
+
+It’s a cost function that is used as loss for machine learning models, telling us how bad it’s performing, the lower the better.
+
+I’m going to explain it word by word, hopefully that will make it. easier to understand.
+
+Negative: obviously means multiplying by -1. What? The loss of our model. Most machine learning frameworks only have minimization optimizations, but we want to maximize the probability of choosing the correct category.
+
+We can **maximize by minimizing the negative log likelihood,** there you have it, we want somehow to maximize by minimizing.
+
+Also it’s much easier to reason about the loss this way, to be consistent with the rule of loss functions approaching 0 as the model gets better.
+
+
+cross entropy loss is same as negative log likelihood
+
+
+NLL uses a negative connotation since the probabilities (or likelihoods) vary between zero and one, and the logarithms of values in this range are negative. In the end, the loss value becomes positive.
+
+
+
diff --git a/code/all_results.json b/code/all_results.json
new file mode 100644
index 0000000000000000000000000000000000000000..0ef196cf326af01f39e80914f549770aa1e1c72a
--- /dev/null
+++ b/code/all_results.json
@@ -0,0 +1,12 @@
+{
+ "epoch": 1.0,
+ "eval_accuracy": 0.9774436090225563,
+ "eval_loss": 0.10330713540315628,
+ "eval_runtime": 10.9904,
+ "eval_samples_per_second": 12.101,
+ "eval_steps_per_second": 1.547,
+ "train_loss": 0.3343511177943303,
+ "train_runtime": 232.7119,
+ "train_samples_per_second": 4.443,
+ "train_steps_per_second": 0.279
+}
\ No newline at end of file
diff --git a/code/classification.md b/code/classification.md
new file mode 100644
index 0000000000000000000000000000000000000000..cf9cd60cbfd4ff0fbda8e468189d966132e68106
--- /dev/null
+++ b/code/classification.md
@@ -0,0 +1,88 @@
+# Logistic Regression
+
+References:
+https://www.kdnuggets.com/2020/01/guide-precision-recall-confusion-matrix.html
+https://developers.google.com/machine-learning/crash-course/classification/thresholding
+https://machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-classification-in-python/
+
+https://developers.google.com/machine-learning/crash-course/logistic-regression/model-training
+
+### Thresholding
+
+A logistic regression model that returns 0.9995 for a particular email message is predicting that it is very likely to be spam. Conversely, another email message with a prediction score of 0.0003 on that same logistic regression model is very likely not spam. However, what about an email message with a prediction score of 0.6? In order to map a logistic regression value to a binary category, you must define a classification threshold (also called the decision threshold). A value above that threshold indicates "spam"; a value below indicates "not spam." It is tempting to assume that the classification threshold should always be 0.5, but thresholds are problem-dependent, and are therefore values that you must tune.
+
+### Accuracy
+
+$
+Accuracy = Total correct / total predictions
+$
+
+Using the Confusion Matrix values
+
+$
+Accuracy = TP + TN / TP + FP + TN + FN
+$
+
+Accuracy alone doesn't tell the full story when you're working with a **class-imbalanced data** set, like this one, where there is a significant disparity between the number of positive and negative labels.
+
+### Precision
+
+Precision — Also called Positive predictive value
+The ratio of correct positive predictions to the *total predicted positives.*
+
+$
+Precision = \frac{TP}{TP + FP}
+$
+
+
+### Recall
+
+Recall — Also called Sensitivity, Probability of Detection, True Positive Rate
+
+The ratio of correct positive predictions to the *total positives examples.*
+
+$
+Recall = \frac{TP}{TP + FN}
+$
+
+### ROC & AUC
+
+* ROC Curves summarize the trade-off between the true positive rate and false positive rate for a predictive model using different probability thresholds.
+
+* Precision-Recall curves summarize the trade-off between the true positive rate and the positive predictive value for a predictive model using different probability thresholds.
+
+* ROC curves are appropriate when the observations are balanced between each class, whereas precision-recall curves are appropriate for imbalanced datasets.
+
+
+### sklearn functions
+
+https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
+https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html
+
+
+### What about using XGBoost for classification?
+
+We can still use XGBoost but logistic regression is linear and XGBoost is *not* linear.
+
+For example we can see here that we are drawing linear boundaries between classifications in the iris dataset.
+
+https://scikit-learn.org/stable/auto_examples/linear_model/plot_iris_logistic.html#sphx-glr-auto-examples-linear-model-plot-iris-logistic-py
+
+
+### What about difference between SVM and logistic regression?
+
+
+### Logistic Regression Loss function
+
+**This always trips me up because some people call it *log loss* or cross entropy or logits or something else!**
+
+The loss function for linear regression is squared loss. The loss function for logistic regression is Log Loss, which is defined as follows:
+$
+put formula in here later
+$
+
+is the data set containing many labeled examples, which are
+pairs.
+is the label in a labeled example. Since this is logistic regression, every value of
+must either be 0 or 1.
+is the predicted value (somewhere between 0 and 1), given the set of features in .
diff --git a/code/config.json b/code/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..47fca59b032d71111121441beb6d74e6c290ff5b
--- /dev/null
+++ b/code/config.json
@@ -0,0 +1,32 @@
+{
+ "_name_or_path": "google/vit-base-patch16-224-in21k",
+ "architectures": [
+ "ViTForImageClassification"
+ ],
+ "attention_probs_dropout_prob": 0.0,
+ "hidden_act": "gelu",
+ "hidden_dropout_prob": 0.0,
+ "hidden_size": 768,
+ "id2label": {
+ "0": "angular_leaf_spot",
+ "1": "bean_rust",
+ "2": "healthy"
+ },
+ "image_size": 224,
+ "initializer_range": 0.02,
+ "intermediate_size": 3072,
+ "label2id": {
+ "angular_leaf_spot": "0",
+ "bean_rust": "1",
+ "healthy": "2"
+ },
+ "layer_norm_eps": 1e-12,
+ "model_type": "vit",
+ "num_attention_heads": 12,
+ "num_channels": 3,
+ "num_hidden_layers": 12,
+ "patch_size": 16,
+ "qkv_bias": true,
+ "torch_dtype": "float32",
+ "transformers_version": "4.14.1"
+}
diff --git a/code/cracks.py b/code/cracks.py
new file mode 100644
index 0000000000000000000000000000000000000000..64b24e7e18245e134463303efd7c6c7762e6a568
--- /dev/null
+++ b/code/cracks.py
@@ -0,0 +1,32 @@
+from autodistill_grounded_sam import GroundedSAM
+from autodistill.detection import CaptionOntology
+from autodistill.utils import plot
+import cv2
+
+# define an ontology to map class names to our OWLv2 prompt
+# the ontology dictionary has the format {caption: class}
+# where caption is the prompt sent to the base model, and class is the label that will
+# be saved for that caption in the generated annotations
+# then, load the model
+classes = ["crack"]
+
+base_model = GroundedSAM(ontology=CaptionOntology({"crack": "crack"}))
+
+results = base_model.predict("crack.png")
+
+image = cv2.imread("crack.png")
+
+# Print image properties
+print("Image shape:", image.shape) # Shows (height, width, channels)
+print("Image dtype:", image.dtype) # Shows data type of the image array
+print("Image size:", image.size) # Shows total number of pixels * channels
+
+
+plot(
+ image=image,
+ detections=results,
+ classes=[classes[i] for i in results.class_id],
+)
+
+
+print(results)
diff --git a/code/creditcard.csv b/code/creditcard.csv
new file mode 100644
index 0000000000000000000000000000000000000000..56948473a7fb0ce73e0407503899e5d454076077
--- /dev/null
+++ b/code/creditcard.csv
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76274b691b16a6c49d3f159c883398e03ccd6d1ee12d9d8ee38f4b4b98551a89
+size 150828752
diff --git a/code/cs224N_pytorch_tutorial_nlp.ipynb b/code/cs224N_pytorch_tutorial_nlp.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ef963a6ff3c64dc0f48ce6b07e7ab0076ca6fff0
--- /dev/null
+++ b/code/cs224N_pytorch_tutorial_nlp.ipynb
@@ -0,0 +1,981 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch \n",
+ "import torch.nn as nn\n",
+ "\n",
+ "import pprint \n",
+ "pp = pprint.PrettyPrinter()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Tensors "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1, 2, 3], [4, 5, 6]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "list_of_lists = [[1 ,2, 3], [4,5,6]]\n",
+ "print(list_of_lists)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[0, 1],\n",
+ " [2, 3],\n",
+ " [4, 5]])"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#init a tensor\n",
+ "data = torch.tensor([\n",
+ " [0,1],\n",
+ " [2,3],\n",
+ " [4,5]\n",
+ "])\n",
+ "data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[0., 1.],\n",
+ " [2., 3.],\n",
+ " [4., 5.]])"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# we can cast them to different types -- usualloy float32 or int\n",
+ "data = torch.tensor([\n",
+ " [0,1],\n",
+ " [2,3],\n",
+ " [4,5],\n",
+ "] , dtype=torch.float32)\n",
+ "data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "torch.Size([3, 2])"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data2 = torch.tensor([\n",
+ " [1, 2, 3],\n",
+ " [4, 5, 6]\n",
+ "], dtype=torch.float32)\n",
+ "\n",
+ "# must be same type \n",
+ "data3 = data @ data2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "rr = torch.arange(1, 10)\n",
+ "rr"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])\n",
+ "tensor([[ 1, 2, 3],\n",
+ " [ 4, 5, 6],\n",
+ " [ 7, 8, 9],\n",
+ " [10, 11, 12],\n",
+ " [13, 14, 15]])\n",
+ "torch.Size([5, 3])\n"
+ ]
+ }
+ ],
+ "source": [
+ "# can reshape a vector into a matrix! \n",
+ "# evidently this can make batch operations easier \n",
+ "# e.x. take a 15 element row vector and turn it into a 5 x 3 matrix \n",
+ "vec = torch.arange(1,16)\n",
+ "print(vec)\n",
+ "matrix = vec.view(5,3)\n",
+ "print(matrix)\n",
+ "print(matrix.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# one of the reason we use tensors is vectorized operations: \n",
+ "# operations that be conducted in parallel over a paarticular dimension of a tensor \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([42., 57., 72.])"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# things we can do like sum, mean, and std dev \n",
+ "\n",
+ "# https://stackoverflow.com/questions/55691819/why-does-dim-1-return-row-indices-in-torch-argmax\n",
+ "\n",
+ "# dim=1 is ROWS \n",
+ "data3.mean(dim=1)\n",
+ "data3.sum(dim=1)\n",
+ "\n",
+ "# dim=0 is COLUMNS\n",
+ "data3.mean(dim=0)\n",
+ "data3.sum(dim=0)\n",
+ "\n",
+ "# look at the official pytorch tutorial for a good example of all the way you can slice a tensor\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Autograd \n",
+ "\n",
+ "Pytorch is known for it's auto differentation feature.. We can call the `backward()` method to ask Pytorch to calculate the gradients which are then stored in the `grad` attribute"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "None\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = torch.tensor([2], dtype=torch.float32, requires_grad=True)\n",
+ "\n",
+ "pp.pprint(x.grad)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dataset statistics
| Number of variables | 5 |
|---|---|
| Number of observations | 100 |
| Missing cells | 0 |
| Missing cells (%) | 0.0% |
| Duplicate rows | 0 |
| Duplicate rows (%) | 0.0% |
| Total size in memory | 4.0 KiB |
| Average record size in memory | 41.3 B |
Variable types
| Numeric | 5 |
|---|
Reproduction
| Analysis started | 2023-11-09 22:44:51.152491 |
|---|---|
| Analysis finished | 2023-11-09 22:44:52.582947 |
| Duration | 1.43 second |
| Software version | ydata-profiling v0.0.dev0 |
| Download configuration | config.json |
a
Real number (ℝ)
| Distinct | 100 |
|---|---|
| Distinct (%) | 100.0% |
| Missing | 0 |
| Missing (%) | 0.0% |
| Infinite | 0 |
| Infinite (%) | 0.0% |
| Mean | 0.49957568 |
| Minimum | 0.024516893 |
|---|---|
| Maximum | 0.99068183 |
| Zeros | 0 |
| Zeros (%) | 0.0% |
| Negative | 0 |
| Negative (%) | 0.0% |
| Memory size | 928.0 B |
Quantile statistics
| Minimum | 0.024516893 |
|---|---|
| 5-th percentile | 0.056429077 |
| Q1 | 0.28251422 |
| median | 0.45642179 |
| Q3 | 0.74517201 |
| 95-th percentile | 0.96516627 |
| Maximum | 0.99068183 |
| Range | 0.96616494 |
| Interquartile range (IQR) | 0.46265778 |
Descriptive statistics
| Standard deviation | 0.29892558 |
|---|---|
| Coefficient of variation (CV) | 0.59835896 |
| Kurtosis | -1.2342932 |
| Mean | 0.49957568 |
| Median Absolute Deviation (MAD) | 0.24013465 |
| Skewness | 0.12337419 |
| Sum | 49.957568 |
| Variance | 0.089356503 |
| Monotonicity | Not monotonic |
Histogram with fixed size bins (bins=50)
| Value | Count | Frequency (%) |
| 0.692727662 | 1 | 1.0% |
| 0.9588277215 | 1 | 1.0% |
| 0.8575828919 | 1 | 1.0% |
| 0.8755208091 | 1 | 1.0% |
| 0.9301186847 | 1 | 1.0% |
| 0.1113302786 | 1 | 1.0% |
| 0.9431724377 | 1 | 1.0% |
| 0.4932534482 | 1 | 1.0% |
| 0.4855559533 | 1 | 1.0% |
| 0.2742635884 | 1 | 1.0% |
| Other values (90) | 90 |
| Value | Count | Frequency (%) |
| 0.02451689344 | 1 | |
| 0.03678303327 | 1 | |
| 0.0529701128 | 1 | |
| 0.05603817851 | 1 | |
| 0.05635858511 | 1 | |
| 0.05643278679 | 1 | |
| 0.05938700409 | 1 | |
| 0.0799270728 | 1 | |
| 0.08669468261 | 1 | |
| 0.09159729141 | 1 |
| Value | Count | Frequency (%) |
| 0.9906818285 | 1 | |
| 0.9796626472 | 1 | |
| 0.9713465976 | 1 | |
| 0.9699754527 | 1 | |
| 0.9653541198 | 1 | |
| 0.9651563784 | 1 | |
| 0.9636081111 | 1 | |
| 0.9588277215 | 1 | |
| 0.9431724377 | 1 | |
| 0.9382258124 | 1 |
b
Real number (ℝ)
| Distinct | 100 |
|---|---|
| Distinct (%) | 100.0% |
| Missing | 0 |
| Missing (%) | 0.0% |
| Infinite | 0 |
| Infinite (%) | 0.0% |
| Mean | 0.505266 |
| Minimum | 0.0062097007 |
|---|---|
| Maximum | 0.99417296 |
| Zeros | 0 |
| Zeros (%) | 0.0% |
| Negative | 0 |
| Negative (%) | 0.0% |
| Memory size | 928.0 B |
Quantile statistics
| Minimum | 0.0062097007 |
|---|---|
| 5-th percentile | 0.091460039 |
| Q1 | 0.27123906 |
| median | 0.51447781 |
| Q3 | 0.69061454 |
| 95-th percentile | 0.94536935 |
| Maximum | 0.99417296 |
| Range | 0.98796326 |
| Interquartile range (IQR) | 0.41937548 |
Descriptive statistics
| Standard deviation | 0.27211408 |
|---|---|
| Coefficient of variation (CV) | 0.53855608 |
| Kurtosis | -1.0654893 |
| Mean | 0.505266 |
| Median Absolute Deviation (MAD) | 0.20940444 |
| Skewness | 0.025068695 |
| Sum | 50.5266 |
| Variance | 0.07404607 |
| Monotonicity | Not monotonic |
Histogram with fixed size bins (bins=50)
| Value | Count | Frequency (%) |
| 0.128987448 | 1 | 1.0% |
| 0.6507482223 | 1 | 1.0% |
| 0.2227952323 | 1 | 1.0% |
| 0.09167554304 | 1 | 1.0% |
| 0.1115540147 | 1 | 1.0% |
| 0.9941729637 | 1 | 1.0% |
| 0.3476079507 | 1 | 1.0% |
| 0.5700943864 | 1 | 1.0% |
| 0.6508226272 | 1 | 1.0% |
| 0.1839457447 | 1 | 1.0% |
| Other values (90) | 90 |
| Value | Count | Frequency (%) |
| 0.006209700668 | 1 | |
| 0.0257783899 | 1 | |
| 0.05447883258 | 1 | |
| 0.07700319387 | 1 | |
| 0.0873654595 | 1 | |
| 0.09167554304 | 1 | |
| 0.09506882661 | 1 | |
| 0.1115540147 | 1 | |
| 0.1148774826 | 1 | |
| 0.1280873131 | 1 |
| Value | Count | Frequency (%) |
| 0.9941729637 | 1 | |
| 0.9817906877 | 1 | |
| 0.9780868341 | 1 | |
| 0.958209005 | 1 | |
| 0.9515261241 | 1 | |
| 0.9450453103 | 1 | |
| 0.9430485729 | 1 | |
| 0.9076302735 | 1 | |
| 0.9025179627 | 1 | |
| 0.8996143151 | 1 |
c
Real number (ℝ)
| Distinct | 100 |
|---|---|
| Distinct (%) | 100.0% |
| Missing | 0 |
| Missing (%) | 0.0% |
| Infinite | 0 |
| Infinite (%) | 0.0% |
| Mean | 0.49043766 |
| Minimum | 0.032613158 |
|---|---|
| Maximum | 0.95219118 |
| Zeros | 0 |
| Zeros (%) | 0.0% |
| Negative | 0 |
| Negative (%) | 0.0% |
| Memory size | 928.0 B |
Quantile statistics
| Minimum | 0.032613158 |
|---|---|
| 5-th percentile | 0.088030713 |
| Q1 | 0.22815811 |
| median | 0.4966044 |
| Q3 | 0.70855991 |
| 95-th percentile | 0.91987776 |
| Maximum | 0.95219118 |
| Range | 0.91957802 |
| Interquartile range (IQR) | 0.48040179 |
Descriptive statistics
| Standard deviation | 0.27909369 |
|---|---|
| Coefficient of variation (CV) | 0.56907069 |
| Kurtosis | -1.3246281 |
| Mean | 0.49043766 |
| Median Absolute Deviation (MAD) | 0.24133101 |
| Skewness | 0.066394797 |
| Sum | 49.043766 |
| Variance | 0.07789329 |
| Monotonicity | Not monotonic |
Histogram with fixed size bins (bins=50)
| Value | Count | Frequency (%) |
| 0.8080291118 | 1 | 1.0% |
| 0.6055218878 | 1 | 1.0% |
| 0.247604652 | 1 | 1.0% |
| 0.1889918353 | 1 | 1.0% |
| 0.5539613155 | 1 | 1.0% |
| 0.2029389504 | 1 | 1.0% |
| 0.6742758564 | 1 | 1.0% |
| 0.9009345819 | 1 | 1.0% |
| 0.08829236624 | 1 | 1.0% |
| 0.5794832799 | 1 | 1.0% |
| Other values (90) | 90 |
| Value | Count | Frequency (%) |
| 0.03261315782 | 1 | |
| 0.06668776888 | 1 | |
| 0.06959057161 | 1 | |
| 0.08255066855 | 1 | |
| 0.08305930832 | 1 | |
| 0.08829236624 | 1 | |
| 0.09468349966 | 1 | |
| 0.1132428092 | 1 | |
| 0.1304513868 | 1 | |
| 0.135235747 | 1 |
| Value | Count | Frequency (%) |
| 0.9521911795 | 1 | |
| 0.9478424968 | 1 | |
| 0.9351804261 | 1 | |
| 0.9329653628 | 1 | |
| 0.9235117979 | 1 | |
| 0.9196864911 | 1 | |
| 0.9181320545 | 1 | |
| 0.9153990512 | 1 | |
| 0.9057096456 | 1 | |
| 0.903777777 | 1 |
d
Real number (ℝ)
| Distinct | 100 |
|---|---|
| Distinct (%) | 100.0% |
| Missing | 0 |
| Missing (%) | 0.0% |
| Infinite | 0 |
| Infinite (%) | 0.0% |
| Mean | 0.50789841 |
| Minimum | 0.015718867 |
|---|---|
| Maximum | 0.97805547 |
| Zeros | 0 |
| Zeros (%) | 0.0% |
| Negative | 0 |
| Negative (%) | 0.0% |
| Memory size | 928.0 B |
Quantile statistics
| Minimum | 0.015718867 |
|---|---|
| 5-th percentile | 0.061207831 |
| Q1 | 0.21544568 |
| median | 0.52796698 |
| Q3 | 0.75222717 |
| 95-th percentile | 0.96436383 |
| Maximum | 0.97805547 |
| Range | 0.9623366 |
| Interquartile range (IQR) | 0.5367815 |
Descriptive statistics
| Standard deviation | 0.29987035 |
|---|---|
| Coefficient of variation (CV) | 0.59041403 |
| Kurtosis | -1.2775209 |
| Mean | 0.50789841 |
| Median Absolute Deviation (MAD) | 0.28207039 |
| Skewness | -0.058003053 |
| Sum | 50.789841 |
| Variance | 0.089922227 |
| Monotonicity | Not monotonic |
Histogram with fixed size bins (bins=50)
| Value | Count | Frequency (%) |
| 0.2555656275 | 1 | 1.0% |
| 0.9584065195 | 1 | 1.0% |
| 0.2367542838 | 1 | 1.0% |
| 0.8578074436 | 1 | 1.0% |
| 0.2030326253 | 1 | 1.0% |
| 0.103727807 | 1 | 1.0% |
| 0.6113663366 | 1 | 1.0% |
| 0.684923487 | 1 | 1.0% |
| 0.4159343424 | 1 | 1.0% |
| 0.5241488975 | 1 | 1.0% |
| Other values (90) | 90 |
| Value | Count | Frequency (%) |
| 0.01571886665 | 1 | |
| 0.02034576539 | 1 | |
| 0.02159492807 | 1 | |
| 0.03096533792 | 1 | |
| 0.05520795333 | 1 | |
| 0.06152361388 | 1 | |
| 0.07065053284 | 1 | |
| 0.08738141679 | 1 | |
| 0.09585290149 | 1 | |
| 0.103727807 | 1 |
| Value | Count | Frequency (%) |
| 0.9780554701 | 1 | |
| 0.9768563315 | 1 | |
| 0.9768076143 | 1 | |
| 0.9765575299 | 1 | |
| 0.9684752556 | 1 | |
| 0.9641474393 | 1 | |
| 0.9587455368 | 1 | |
| 0.9584065195 | 1 | |
| 0.9361862209 | 1 | |
| 0.915946169 | 1 |
e
Real number (ℝ)
| Distinct | 100 |
|---|---|
| Distinct (%) | 100.0% |
| Missing | 0 |
| Missing (%) | 0.0% |
| Infinite | 0 |
| Infinite (%) | 0.0% |
| Mean | 0.51927403 |
| Minimum | 0.0075182289 |
|---|---|
| Maximum | 0.99588817 |
| Zeros | 0 |
| Zeros (%) | 0.0% |
| Negative | 0 |
| Negative (%) | 0.0% |
| Memory size | 928.0 B |
Quantile statistics
| Minimum | 0.0075182289 |
|---|---|
| 5-th percentile | 0.059937707 |
| Q1 | 0.31246052 |
| median | 0.51282968 |
| Q3 | 0.75658275 |
| 95-th percentile | 0.9462708 |
| Maximum | 0.99588817 |
| Range | 0.98836994 |
| Interquartile range (IQR) | 0.44412223 |
Descriptive statistics
| Standard deviation | 0.27661502 |
|---|---|
| Coefficient of variation (CV) | 0.53269566 |
| Kurtosis | -1.0870807 |
| Mean | 0.51927403 |
| Median Absolute Deviation (MAD) | 0.21710688 |
| Skewness | -0.0092921597 |
| Sum | 51.927403 |
| Variance | 0.07651587 |
| Monotonicity | Not monotonic |
Histogram with fixed size bins (bins=50)
| Value | Count | Frequency (%) |
| 0.3871996414 | 1 | 1.0% |
| 0.5432698786 | 1 | 1.0% |
| 0.664230381 | 1 | 1.0% |
| 0.339504853 | 1 | 1.0% |
| 0.9548257011 | 1 | 1.0% |
| 0.0598363319 | 1 | 1.0% |
| 0.5058581683 | 1 | 1.0% |
| 0.3713983015 | 1 | 1.0% |
| 0.184923381 | 1 | 1.0% |
| 0.4081663892 | 1 | 1.0% |
| Other values (90) | 90 |
| Value | Count | Frequency (%) |
| 0.007518228888 | 1 | |
| 0.02395584274 | 1 | |
| 0.02606281113 | 1 | |
| 0.05097207848 | 1 | |
| 0.0598363319 | 1 | |
| 0.05994304291 | 1 | |
| 0.1134238708 | 1 | |
| 0.1171189808 | 1 | |
| 0.1174560911 | 1 | |
| 0.1280367266 | 1 |
| Value | Count | Frequency (%) |
| 0.9958881697 | 1 | |
| 0.9898059367 | 1 | |
| 0.9574475418 | 1 | |
| 0.9548257011 | 1 | |
| 0.9523822617 | 1 | |
| 0.9459491449 | 1 | |
| 0.932505397 | 1 | |
| 0.9187539656 | 1 | |
| 0.9106651935 | 1 | |
| 0.9096051544 | 1 |
| a | b | c | d | e | |
|---|---|---|---|---|---|
| a | 1.000 | -0.190 | -0.077 | 0.038 | -0.007 |
| b | -0.190 | 1.000 | -0.008 | 0.028 | -0.115 |
| c | -0.077 | -0.008 | 1.000 | -0.023 | -0.022 |
| d | 0.038 | 0.028 | -0.023 | 1.000 | -0.012 |
| e | -0.007 | -0.115 | -0.022 | -0.012 | 1.000 |
A simple visualization of nullity by column.
Nullity matrix is a data-dense display which lets you quickly visually pick out patterns in data completion.
| a | b | c | d | e | |
|---|---|---|---|---|---|
| 0 | 0.692728 | 0.128987 | 0.808029 | 0.255566 | 0.387200 |
| 1 | 0.585674 | 0.355609 | 0.176789 | 0.755023 | 0.836276 |
| 2 | 0.091597 | 0.880260 | 0.204424 | 0.449932 | 0.932505 |
| 3 | 0.573852 | 0.852087 | 0.268319 | 0.603409 | 0.625983 |
| 4 | 0.310915 | 0.899614 | 0.597281 | 0.477727 | 0.864602 |
| 5 | 0.937270 | 0.209843 | 0.150858 | 0.864684 | 0.910665 |
| 6 | 0.348602 | 0.344620 | 0.508842 | 0.968475 | 0.568849 |
| 7 | 0.317874 | 0.627413 | 0.069591 | 0.055208 | 0.894718 |
| 8 | 0.330687 | 0.565535 | 0.310726 | 0.976808 | 0.995888 |
| 9 | 0.154088 | 0.676263 | 0.250755 | 0.978055 | 0.117119 |
| a | b | c | d | e | |
|---|---|---|---|---|---|
| 90 | 0.359040 | 0.675886 | 0.814423 | 0.976856 | 0.320967 |
| 91 | 0.734883 | 0.420127 | 0.767862 | 0.637759 | 0.795147 |
| 92 | 0.327385 | 0.095069 | 0.454402 | 0.160721 | 0.784028 |
| 93 | 0.415717 | 0.704654 | 0.835378 | 0.450970 | 0.846659 |
| 94 | 0.417997 | 0.852187 | 0.903778 | 0.661458 | 0.820408 |
| 95 | 0.349571 | 0.054479 | 0.846283 | 0.481468 | 0.638080 |
| 96 | 0.634186 | 0.306311 | 0.429997 | 0.020346 | 0.918754 |
| 97 | 0.101500 | 0.644602 | 0.787099 | 0.378777 | 0.945949 |
| 98 | 0.971347 | 0.540891 | 0.709030 | 0.659904 | 0.665010 |
| 99 | 0.867169 | 0.907630 | 0.609768 | 0.536729 | 0.128037 |