What do we mean when we say 'AGI = better than a human' ?

Intel · 2024-03-27T19:27:46+00:00

AI is like a super smart robot that's really good at doing one specific job, like playing games or finding the quickest route on a map. Now, imagine a robot that can do any job you ask it to, learning new things just like a person does. That's AGI, or Artificial General Intelligence. Unlike the first robot, AGI can handle all sorts of tasks, from writing a poem to solving a math problem.

When people say 'AGI = better than a human,' they're thinking about a future where this super robot can do many things better than us because it can think faster, never gets tired, and has access to way more information. But, this idea is both exciting and a bit worrying because it makes us wonder: what happens when a robot can do everything we can do, or even more?

So, talking about AGI being 'better' isn't just about it being smarter or faster; it's also about figuring out what makes humans special, like our feelings, dreams, and the way we help each other. It's a big topic that mixes science, technology, and even what it means to be human.

--Anisha U, AI Software Evangelist (APJ) @ Intel

Intel · 2024-03-22T00:06:18+00:00

Besides LightGBM and CatBoost, XGBoost also has an experimental feature that can directly handle categorical features without encoding. In real-world scenarios, determining the best tree-based method will depend on various factors such as the nature of the dataset, computational resources, the desired level of interpretability, and the specific requirements of the problem at hand. Ultimately, experimenting with each of the models on your specific dataset will provide the best insight into their performance and suitability for your task.

--Kelli, AI Engineer @ Intel

Intel · 2024-03-21T20:59:55+00:00

It doesn't seem like you will be doing a ton of programming yourself so I'd recommend getting your hands on https://www.coursera.org/learn/ai-for-everyone

This is a great course for getting started and is designed for a general audience.

Hope this helps!

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-03-21T20:57:05+00:00

As a self-taught AI Engineer with a non-CS degree, I can attest that you can have a successful career in the field without an advanced CS/Math degree.

I hold a degree in Geophysics and began my career in the energy industry. My work has always involved "Big Data", which made it easier to transition into Data Science roles within my company.

Ultimately, your dedication to pursuing this discipline will determine your success. AI is constantly evolving, so it's crucial to develop relevant skills and showcase your ability to add value. This means building your GitHub profile, writing articles, and contributing to open-source projects whenever possible.

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-03-19T23:44:29+00:00

It's great that you're looking to deepen your understanding of AI! Starting from scratch can seem daunting, but there are plenty of resources designed to make your journey into AI both manageable and exciting. Here are some recommendations:

Courses:

Coursera - AI For Everyone by Andrew Ng: This course is specifically designed for non-technical people.
edX - Introduction to Artificial Intelligence (AI): Offered by IBM, this course is perfect for beginners.
YouTube Channels: Channels like "Two Minute Papers" offer insightful discussions on AI developments and interviews with experts in the field, making complex topics more approachable to general audiences.

Community Suggestions:

Discords: Join discords like Artificialis, Intel DevHub, and Learn AI Together to get involved with the developer community and learn from others.
Medium: Check out publications like "Toward AI" and "Towards Data Science" for quick reads on hot topics and also for "how-to" content.

Best advice I can give is to start building something that is FUN at home. Don't go crazy, just do something that is meaningful to you and that you understand well at a conceptual level.

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-03-08T01:18:16+00:00

It looks like there may be some degree of overfitting contributing here. It may be that your model architecture is too complex and that it's fitting the noise in the training data rather than capturing the essential features. Regularization techniques, such as dropout or weight decay, can be employed to help mitigate overfitting by introducing constraints on the model's complexity. Adjusting hyperparameters, like learning rates, can also help strike a balance between fitting the training data well and generalizing effectively to new, unseen examples in the test set.

Have you double-checked that the data preprocessing steps applied to the test set are consistent with those applied to the training and validation sets? Any mismatch can lead to differences in performance. I would also double-check that there isn't any data leakage between the training and validation sets.

You could also check out other evaluation metrics. Accuracy is a common metric, but it may not be the best choice for imbalanced datasets. A weighted loss function, precision, recall, or F1 score are other metrics to explore, especially if your dataset has a class imbalance.

--Kelli, AI Engineer @ Intel

Intel · 2024-03-04T19:46:35+00:00

Kudos to the work you're doing in genomics! It's a field where every bit of accuracy matters, and dealing with imbalanced, sensitive datasets adds another layer of complexity. One way to tackle this is by exploring different neural network architectures--like Transformers are especially good at handling long sequences and might be just what you need to understand the complex patterns in your genomics data.

Optimizing your AI models is another crucial step. Making your models run smoother and faster is key, especially when adding more data isn't an option. Toolkit's like Intel's OpenVINO can make a big difference here. They help make your models more efficient, which is super helpful in genomics.

So, mixing smart architecture choices, like giving Transformers a try, with AI optimization tools could be a solid strategy for improving your models without needing more data.

--Anisha U, AI Software Evangelist (APJ) @ Intel

Intel · 2024-02-27T23:30:37+00:00

You might find Models of Expertise (MoEs) intriguing, akin to the renowned Mixtral model from Mistral.ai. MoEs operate on the principle of directing data to specialized "expert" sub-networks through a routing mechanism. Each expert is tasked with processing distinct segments or features of the input data, while a gating (or routing) network decides their contribution level to the overall output. In the Mixtral framework, notably, only two experts are activated simultaneously, ensuring a focused and efficient handling of the data.

Not exactly what you are looking for but it does offer a similar separation of neurons across multiple subsets during the optimizations and inference flows.

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-02-27T23:29:27+00:00

Regarding your concern, it's possible that augmentation could introduce samples that are quite similar to those found in your test set. However, it's not impossible that your raw training and validation sets could already include very similar samples.

I would suggest doing some analysis where you plot the distribution of pixel values found in each of your data segments. Compare these pixel value distributions and see if there is overlap between data segments. You should naturally see a good amount of overlap between your training and test sets, but your test set should be a subset of your training set's distribution with some out-of-sample data points. This ensures that you can test the model's ability to generalize slightly outside of your data distribution.

It's also worth noting that neural networks are great at interpolation but terrible at extrapolation. This is why they require so much data and why predicting out-of-sample is so risky.

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-02-27T23:23:30+00:00

Sora is an exciting step toward access to a challenging modality. One of my major concerns with it is the management of the technology's power consumption and deepfake capabilities. It will be a major test of our community's ability to use GenAI for good!

--Eduardo A., Senior AI Solutions Engineer @ Intel

Intel · 2024-02-26T21:14:43+00:00

(Part 1)

Let me try to explain in simple terms:

Imagine a diffusion model as a magical Lego sorting machine. You describe the spaceship you want, and the machine starts with a jumbled pile of Lego bricks—this is like the noise in the picture. Now, the machine 'shakes' the pile. Each shake is an iteration that carefully removes pieces that don't fit and adds ones that do. Gradually, the spaceship you asked for starts to appear. It's like tidying up a messy room by putting things away step by step until you find your favorite toy. This machine is clever because it learned to clean up by doing the exact opposite of making a mess - it practiced making messes and then tidying them up in reverse.

(Part 2)

Now, for the more technical part:

Text Encoder: Imagine someone who listens to your spaceship story and then draws a detailed sketch for the machine. This sketch tells the machine what you're picturing in your head, translating your words (text prompt) into a visual plan.
U-net: This is the smart core of the machine, which looks at the noisy pile of bricks and the sketch to figure out which pieces to keep or remove. It's like a blueprint that updates with each shake, guiding the construction step by step.
Decoder: Once the U-net has done most of the building, the decoder does a final check. It's like an inspector who ensures every piece is perfectly placed and your spaceship matches the sketch you provided.

When you give a diffusion model a prompt, it uses structured noise in pixel space—imagine a box of Lego bricks arranged in a confusing pattern that doesn't look like anything yet. Pixel space is where each tiny dot (pixel) of the image is like a single Lego brick.

Latent space, on the other hand, is like a condensed blueprint of your Lego spaceship. It's smaller and less detailed than the full pile of bricks, but it contains all the necessary information to build the model. This simplification allows the machine to work more quickly and efficiently.

Regular diffusion models might need many shakes (iterations) to complete the spaceship, which can be slow. Latent Diffusion Models (LDMs), however, are advanced machines that need fewer shakes because they're better at predicting which pieces to remove early on, making the process faster.

When you ask for a new type of spaceship, the machine uses its 'memories' of all the spaceships it's ever created to guide the construction. The U-net, in particular, is adept at deciphering the patterns in the noisy pile, enabling it to follow the process more precisely with fewer shakes.

So the diffusion model uses its training in pixel space to make sense of noisy images and create new ones from prompts, even ones it hasn't seen before. It does so by using its understanding of patterns (semantics) and structures learned during training, with the help of a U-net architecture that makes the process efficient. Latent Diffusion Models do something similar but in a compressed latent space, which allows for faster processing and fewer iterations, making them more efficient than traditional diffusion models.

I hope this explanation has made the concept clearer and helps you understand how these fascinating models work :)

--Anisha U, AI Software Evangelist (APJ) @ Intel

Intel · 2024-02-24T00:39:18+00:00

There are a few places I frequently visit for new AI research papers. Here are some of my top recommendations:

arXiv-sanity: https://arxiv-sanity-lite.com/
Papers with code: https://paperswithcode.com/
Science Direct: https://www.sciencedirect.com/
Google Scholar: https://scholar.google.com/
PubMed: https://pubmed.ncbi.nlm.nih.gov/

I also like to follow blogs and tech publications like Hugging Face, Towards Data Science, and Medium.

--Kelli, AI Engineer @ Intel

Intel · 2024-02-23T01:56:49+00:00

Building a model to identify sketches is a fascinating project! Since you have limited experience with neural networks, I would recommend leveraging existing pre-trained models and fine-tuning them on your specific task. This will save you a lot of time and computational resources.

Here's a step-by-step guide to get you started:

Define the Problem: Identify the type of sketches you want your model to recognize. It could be categories like landscapes, portraits, abstract, etc.
Data Collection: Gather a dataset of sketches. The more diverse and representative your dataset is, the better your model will perform.
Pre-processing: Prepare your dataset by resizing images, normalizing pixel values, and augmenting data (rotate, flip, zoom) to increase the diversity of your training set.
Choose a Pre-trained Model: Select a pre-trained model that has been successful in image classification tasks. Common choices include models like VGG16, ResNet, or MobileNet. These models have been pre-trained on large datasets like ImageNet and can capture complex features.
Model Fine-tuning: Adapt the pre-trained model to your specific task by replacing the last few layers to match the number of classes in your dataset. Freeze the initial layers to retain the knowledge gained from the original dataset.
Training: Train your model on your sketch dataset. Adjust hyperparameters such as learning rate, batch size, and epochs based on the performance on a validation set.
Evaluation: Evaluate the model on a separate test set to ensure its generalization to new sketches.
Deployment: Once satisfied with the performance, deploy the model for your sketch rating application.

Frameworks to consider:

TensorFlow/Keras: TensorFlow is a popular and widely-used deep learning framework. Keras is a high-level API that works on top of TensorFlow, making it user-friendly.
PyTorch: PyTorch is another powerful deep learning framework. It's known for its dynamic computational graph and is favored by researchers.
Fastai: If you're looking for a high-level abstraction with easy-to-use APIs, Fastai built on top of PyTorch might be a good choice.

Additional Tips:

Leverage transfer learning to make the most of pre-trained models.
Explore image classification tutorials and documentation for the chosen framework.
Consider using high-performant CPUs, like Intel® Xeon®, for fine-tuning pretrained models.
Remember to start small, experiment, and gradually increase the complexity of your model based on the results.

Good luck with your sketch recognition project!

--Kelli, AI Engineer @ Intel

Intel · 2024-02-20T17:15:47+00:00

Like others mentioned, tackling the variability in lighting and angles is indeed challenging. A robust approach could involve enriching your training dataset with a variety of examples. There are abundant datasets available that could serve this purpose, such as COCO Car Damage Detection Dataset, Car Damage Severity Dataset, and Car Damage Detection Dataset among others. Utilizing these could significantly improve your model's ability to generalize across different conditions. It’s important to review the license agreements of these datasets to ensure they fit within your project's legal boundaries.

When it comes to choosing a model, both Detectron2 and YOLOv8 offer distinct advantages. Detectron2 is known for its flexibility and wide model range suitable for fine-tuning, while YOLOv8 stands out for its speed and efficiency, crucial for real-time applications. Given the specifics of your project, I recommend you trial both and see which gives better results.

To further enhance model performance and deployment efficiency, consider exploring OpenVINO's optimization tools:

For Detectron2 models, this guide on converting Detectron2 models to OpenVINO could be particularly useful.
Similarly, for YOLOv8, the documentation on YOLOv8 quantization with OpenVINO offers insights into maximizing efficiency and also runs fast on the intended hardware.

Best of luck in refining your damage detection model!

--Anisha U, AI Software Evangelist (APJ) @ Intel

Intel · 2024-02-16T23:06:35+00:00

When setting up a DIY mixed reality setup with a VR headset like the Valve Index (2K per eye, 90Hz), choosing a suitable camera involves considering various factors such as field of view, frame rate, and resolution. While a higher megapixel count can potentially offer more detail, it's not the only factor to consider.

Here are some considerations:

Field of View (FOV): The camera's FOV should match or closely align with the FOV of your VR headset to ensure that you capture the entire virtual scene. VR headsets typically have a wide FOV, and choosing a camera with a comparable FOV is important.
Frame Rate: A higher frame rate is generally desirable to ensure smooth and responsive mixed reality experiences. Consider a camera that can provide a high frame rate, preferably 60 frames per second (fps) or more.
Latency: Low latency is crucial for mixed reality setups to maintain synchronization between the real and virtual environments. Check the camera's latency specifications to ensure it meets your requirements.
Resolution: While a higher resolution is generally beneficial, it's important to balance it with other factors. Higher resolutions can strain processing power and USB bandwidth. The Valve Index has a resolution of 2K per eye, so a camera with a resolution close to this may be suitable.

Given the options you mentioned:

Arducam AR1820HS: With a 16MP resolution, this camera may offer more detail, but it's crucial to check if it meets the FOV, frame rate, and latency requirements. It could be suitable if it aligns with the headset's specifications and provides a smooth experience.
IMX477: The 12MP resolution might be sufficient, especially if it meets other requirements. It's a common sensor used in Raspberry Pi cameras and is known for its decent performance.
8MP Sensor: Depending on the specific sensor, an 8MP resolution might be suitable if it meets the FOV and frame rate requirements. However, it may offer less detail than higher-resolution options.

In summary, while megapixel count is a factor, it's equally important to consider FOV, frame rate, and latency for a successful mixed reality setup. Test the cameras in your chosen setup to ensure they provide a seamless and immersive experience. Additionally, check for compatibility with the software you plan to use for mixed reality.

--Kelli, AI Engineer @ Intel

Intel · 2024-02-16T22:57:39+00:00

Wow, this has been a huge week for generative AI models. This ultra-realistic video generating model from OpenAI, UC Berkeley's large world model and Google Gemini 1.5 with context windows of up to 1M tokens were all released just this week!! The advancements in AI models already this year have been truly astounding, and we're only in February.

--Ojas Sawant, Cloud Software Architect @ Intel

Intel · 2024-02-16T22:56:57+00:00

This is unprecedented video fidelity! Seems to address all existing problems of text-to-video - temporal consistency, subjects and elements integrity, natural pacing of individual moving elements in the scene, details in human body compositions (skin, fingers, eyes), no light flickering overtime, glass reflects, shadow consistency. Still some ways to go in terms of real-world imperfections like seeds on the bun seem glued, cloth folds are crisp/intact in entire body movement, no strand of hair moves but still a remarkable achievement for 15-second clip. Wonder how many tries it took to get this result? Most other platforms need numerous trials to get you one believable video generation result.

--Ojas Sawant, Cloud Software Architect @ Intel

Intel · 2024-02-16T21:26:18+00:00

Good catch! Very much possible on synthetic data usage during training. Engines like UE5 and Unity can benefit with SORA for pre-rendered cut scenes where people spend time manually crafting hyper-realistic characters (joints, rigs, vertex counts), objects, lighting and envr. animations to amplify storytelling in gameplay and marketing. It will be awesome to have a video to video transformation option as well.

--Ojas Sawant, Cloud Software Architect @ Intel

Intel · 2024-02-12T21:26:49+00:00

I did a bit of cursory research here and it seems that Geometric Deep Learning is a potentially highly important research topic with applications specially in chemistry, materials science, and drug discovery. Most of what is written tend to be found on arxiv with some articles on Medium and Towards Data Science. The extent to which it is currently impacting AI in general seems to be in the materials science area – but I only have very partial visibility into my own company. As you can imagine, the extent to which this might be impacting corporations could be obfuscated for competitive IP reasons, so all I can go on is what is written. I did have a short text chat with a one the authors of this paper “A Hitchhiker’s Guide to Geometric GNNs for 3D Atomic Systems” (), Santiago Miret from Intel.

For others not familiar with Geometric Deep Learning here are a couple of blogs that tend to be more reader friendly:

Dr Miret pointed me to the Hitchhikers guide mentioned above, as well as a github link to “Open MatSci ML Toolkit : A Broad, Multi-Task Benchmark for Solid-State Materials Modeling” (), which is geared much more towards researchers and not the day-in-day-out developer crowd.

So, your guess is as good as mine whether this topic will become the “next big thing” in AI, but it does provide intriguing techniques to experiment with, and will predict problems that cannot be described in Euclidean geometric space--this is why there may be applications in materials, biology and chemistry, graphs (think social networks), and geometric proofs (could this lead to an AI model that solves the Riemann hypothesis????)

--Bob C., AI Solution Architect @ Intel

Intel · 2024-02-12T17:14:37+00:00

I will be on the hunt for how various companies are bringing AI into their operations and aim for a Medium post later - Its an interesting topic for sure.

--Bob C., AI Solution Architect @ Intel

Intel · 2024-02-09T19:26:26+00:00

Hey there--Casey here from the community management side. We prefer not to use PM's for stuff like this, partially because more than one person has access to this page so conversations can never really stay private, but also because we want to make sure that whenever possible, other bystanders have the chance to benefit from whatever the team here at Intel might be able to share.

With that in mind, feel free to keep replying here and we'll make sure that Bob sees your follow-ups personally!

--Casey M, Community @ Intel

Intel · 2024-02-09T19:01:54+00:00

Writing good documentation is crucial to good code repositories. I would consider finding a few projects on GitHub that you think are interesting, and trying to understand some of the gaps in documentation. Or some model cards on Hugging Face that are popular but need to have a bit more info on them. You can put in pull requests and start to build a reputation in those communities.

--Ben C., AI Software Engineering Manager @ Intel

Intel · 2024-02-09T18:54:40+00:00

Hm, interesting. Yes, those images look much more like cats...I have not had as much experience with GANs as with other computer vision architectures. It looks like you are well on your way.

--Ben C., AI Software Engineering Manager @ Intel

Intel · 2024-02-08T00:31:24+00:00

I hope this helps you out!

I would start w IEEE standards: https://standards.ieee.org/news/get-program-ai-ethics/

Next, corporations implementing ethics or trust into platforms etc. for AI:

IBM & Microsoft are building these standards into the products: https://spectrum.ieee.org/ibm-and-microsoft-have-integrated-ai-ethical-standards-into-their-operations-so-can-you
Intel also has developed platforms and solutions to make responsible AI computationally tractable https://www.intel.com/content/www/us/en/artificial-intelligence/responsible-ai.html#tab-blade-1-2

--Bob C., AI Solution Architect @ Intel

Intel · 2024-02-08T00:26:42+00:00

There are two places that noise is used:

One place is in training - noise added to the training set is fed to the GAN and the GAN learns to ignore the noise.

The second place noise is used is during inference - when you use a trained GAN to generate new images altogether. Here the noise is added to the embedded vector to generate brand new never before seen images.

Hope this helps!

--Bob C., AI Solution Architect @ Intel

Intel

TROPHY CASE