Category: Microsoft
Category Archives: Microsoft
Expanding availability of Copilot for Microsoft 365
Today, we announced that we are expanding Copilot for Microsoft 365 to a much broader set of organizations, available across more channels, and without a minimum seat required. We are also extending our data residency commitments for Copilot for Microsoft 365 and bringing Microsoft Copilot Graph-grounded chat to Copilot in Windows. Join the upcoming AMA and Tech Accelerator event and engage with experts from Microsoft to learn more about Copilot for Microsoft 365.
Expanding availability of Copilot for Microsoft 365
Starting today, we have removed the 300-seat minimum purchase for Copilot for Microsoft 365 commercial plans. We have also extended support so that Office 365 E3 and E5 customers are eligible to purchase Copilot, and we’re extending Semantic Index for Copilot to Office 365 users with a paid Copilot license. Finally, we have announced that Copilot for Microsoft 365 is generally available for businesses of all sizes, supported on Microsoft 365 Business Standard or Business Premium. This follows a successful early access program focused specifically on small and medium businesses, as well as the previously announced availability for staff and faculty of education institutions with Microsoft 365 A3 or A5 licenses. Commercial customers—including small and medium-sized businesses—can now purchase Copilot for Microsoft 365 through our network Cloud Solution Provider partners (CSPs) and you can learn more about them here.
We still recommend that customers start by giving Copilot to a critical mass of their information workers. We learned during the early access program that this creates a flywheel of interest and adoption, accelerating time to value and an organization’s ability to measure impact in a meaningful way. Copilot for Microsoft 365 licenses will be capped by the total number of eligible base licenses that a customer has. That is, customers must have a product license of one of the prerequisite base SKUs for each seat of Copilot for Microsoft 365 they purchase. You can review requirements for Copilot here.
Updating data residency commitments
We’ve heard feedback from our Enterprise customers that they need assurances that Copilot data is managed appropriately across geographically diverse teams. To support, Copilot for Microsoft 365 upholds residency commitments as outlined in the Microsoft Product Terms and Data Protection Addendum.
We’re pleased to share that later this year Copilot for Microsoft 365 will be added as a covered workload under the data residency commitments in Microsoft Product Terms and the Microsoft Advanced Data Residency (ADR) and Multi-Geo Capabilities add-ons. For additional information on Copilot for Microsoft 365 privacy and data storage please visit Data, Privacy, and Security for Microsoft Copilot for Microsoft 365. To learn more about our commitments to data residency, see Microsoft 365 Data Residency Overview and Definitions.
Microsoft Copilot capabilities coming to Windows desktop
Organizations will soon be able to experience Copilot for Microsoft 365 integrated in Windows desktop, bringing Graph-grounded chat capabilities to Copilot in Windows for users with a Copilot for Microsoft 365 license. This update will be available to organizations with Copilot for Microsoft 365 and Copilot in Windows enabled, beginning the week of February 4th. This adds a new, simple way for users to access Copilot, in addition to the current surfaces in Teams, Edge, and copilot.microsoft.com. For information on managing Copilot in Windows, review this article.
Start preparing your organization for Copilot for Microsoft 365
There are steps you can take today to get your tenant prepared for Copilot:
Prepare your data and assess all relevant data security, privacy, and compliance controls are in place. Copilot inherits your existing permissions and policies so ensuring that these are in place helps ensure seamless deployment. Conduct access reviews for SharePoint sites, documents and tenant data, employ the use of sensitivity labels to protect important data, and validate policies for data loss prevention, retention, and compliance.
Review prerequisites for Copilot by reviewing overview and requirements for Microsoft 365 Copilot to position your tenant to seamlessly deploy Copilot. This setup guide also provides a simple walkthrough of the process.
Learn more about Copilot for Microsoft 365, how it works, benefits to your organizations, how your data is handled and protected.
Familiarize yourself with the admin controls available to manage Copilot in the Microsoft 365 admin center Copilot page.
Develop your adoption strategy by leveraging the resources available on our adoption site, including this adoption kit and user onboarding toolkit.
Check readiness, measure adoption and impact through the Microsoft Copilot Dashboard (in Preview) in Viva Insights or PowerBI that helps organizations maximize the value of Copilot for Microsoft 365. It provides actionable insights to help your organization get ready to deploy AI, drive adoption based on how AI is transforming workplace behavior and measure the impact of Copilot.
To learn more about Copilot, you can review our documentation hub, requirements, setup, and information about privacy, security, and compliance. You can also watch our sessions at this past Ignite on getting ready for Copilot.
For small and medium business customers, join our discussion forum to collaborate with other Copilot for Microsoft 365 users, take part in community calls with open Q&A, hear directly from Microsoft Copilot engineers, and access exclusive resources. Also, check out the resources available on the small and medium business Copilot adoption site.
For a comprehensive introduction and deep dive into Copilot for Microsoft 365, join us during our Copilot for Microsoft 365 Tech Accelerator, February 28 and 29, right here in the Tech Community. Listen in as experts from Microsoft talk delve into preparing for Copilot with recommendations and best practices, share strategies on driving adoption, and measuring and maximizing value for your organization. There will also be plenty of opportunities to ask questions and engage with our experts.
Finally, join our next Ask Me Anything (AMA) tomorrow at 9am PT, here in the Copilot for Microsoft 365 Tech Community. Feel free to post your questions onto the event page ahead of time, and our panel of experts will answer them during the event.
Microsoft Tech Community – Latest Blogs –Read More
The Publisher failed to allocate a new set of identity ranges for the subscription
Problem:
===========
Assume that you have tables with Identity columns declared as datatype INT and you are using Auto Identity management for those articles in a Merge Publication.
This Publication has one or more subscribers and you tried to re-initialize one subscriber using a new Snapshot.
Merge agent fails with this error:
>>
Source: Merge Replication Provider
Number: -2147199417
Message: The Publisher failed to allocate a new set of identity ranges for the subscription. This can occur when a Publisher or a republishing Subscriber has run out of identity ranges to allocate to its own Subscribers or when an identity column data type does not support an additional identity range allocation. If a republishing Subscriber has run out of identity ranges, synchronize the republishing Subscriber to obtain more identity ranges before restarting the synchronization. If a Publisher runs out of identit
Cause:
============
Identity range Merge agent is trying to allocate, exceeds maximum value an INT datatype can have.
Resolution
=================
Assume that publisher database has only one Merge publication with 2 subscribers, and your merge articles have this definition:
>>>
exec sp_addmergearticle @publication = N’MergeRepl_ReproDB’, @article = N’tblCity’, @source_owner = N’dbo’, @source_object = N’tblCity’, @type = N’table’, @description = N”, @creation_script = N”, @pre_creation_cmd = N’drop’, @schema_option = 0x000000004C034FD1, @identityrangemanagementoption = N’auto’, @pub_identity_range = 1000, @identity_range = 1000, @threshold = 90, @destination_owner = N’dbo’, @force_reinit_subscription = 1, @column_tracking = N’false’, @subset_filterclause = N”, @vertical_partition = N’false’, @verify_resolver_signature = 1, @allow_interactive_resolver = N’false’, @fast_multicol_updateproc = N’true’, @check_permissions = 0, @subscriber_upload_options = 0, @delete_tracking = N’true’, @compensate_for_errors = N’false’, @stream_blob_columns = N’false’, @partition_options = 0
exec sp_addmergearticle @publication = N’MergeRepl_ReproDB’, @article = N’tblCity1′, @source_owner = N’dbo’, @source_object = N’tblCity1′, @type = N’table’, @description = N”, @creation_script = N”, @pre_creation_cmd = N’drop’, @schema_option = 0x000000004C034FD1, @identityrangemanagementoption = N’auto’, @pub_identity_range = 1000, @identity_range = 1000, @threshold = 90, @destination_owner = N’dbo’, @force_reinit_subscription = 1, @column_tracking = N’false’, @subset_filterclause = N”, @vertical_partition = N’false’, @verify_resolver_signature = 1, @allow_interactive_resolver = N’false’, @fast_multicol_updateproc = N’true’, @check_permissions = 0, @subscriber_upload_options = 0, @delete_tracking = N’true’, @compensate_for_errors = N’false’, @stream_blob_columns = N’false’, @partition_options = 0
You can run this query against the Published database to see what articles range is full or have very few values left:
>>>
select a.name,
max_used=max_used,
diff_pub_range_end_max_used=range_end – max_used, –this tells how many values are left
pub_range_begin=range_begin,
pub_range_end=range_end
from dbo.MSmerge_identity_range b ,
sysmergearticles a
where
a.artid = b.artid
and is_pub_range=1
order by max_used desc
name max_used diff_pub_range_end_max_used pub_range_begin pub_range_end
————– ————————————— ————————————— ————————————— ————-
tblCity 2147483647 0 2147477647 2147483647
tblCity1 6001 2147477646 1 2147483647
As you see from above diff_pub_range_end_max_used column is zero for tblCity.
When Merge agent runs depending on how many servers are involved it has to allocate 2 ranges for each.
In the example above we have Publisher and 2 subscribers and @identity_range is 1000. So, we will have to allocate range for 3 servers i.e., 3 * (2*1000) = 6000
Our diff_pub_range_end_max_used should be greater than 6000, only then we will be able to allocate a new range for all the servers.
To resolve the issue.
Remove tblCity table from publication.
Change the datatype from int to bigint and add this table back to publication.
Then generate a new snapshot. It will generate snapshots for all articles, but only this 1 table will be added back to the existing Subscribers.
Microsoft Tech Community – Latest Blogs –Read More
Future-Proofing AI: Strategies for Effective Model Upgrades in Azure OpenAI
TL;DR: This post navigates the intricate world of AI model upgrades, with a spotlight on Azure OpenAI’s embedding models like text-embedding-ada-002. We emphasize the critical importance of consistent model versioning ensuring accuracy and validity in AI applications. The post also addresses the challenges and strategies essential for effectively managing model upgrades, focusing on compatibility and performance testing.
Introduction
What are Embeddings?
Embeddings in machine learning are more than just data transformations. They are the cornerstone of how AI interprets the nuances of language, context, and semantics. By converting text into numerical vectors, embeddings allow AI models to measure similarities and differences in meaning, paving the way for advanced applications in various fields.
Importance of Embeddings
In the complex world of data science and machine learning, embeddings are crucial for handling intricate data types like natural language and images. They transform these data into structured, vectorized forms, making them more manageable for computational analysis. This transformation isn’t just about simplifying data; it’s about retaining and emphasizing the essential features and relationships in the original data, which are vital for precise analysis and decision-making.
Embeddings significantly enhance data processing efficiency. They allow algorithms to swiftly navigate through large datasets, identifying patterns and nuances that are difficult to detect in raw data. This is particularly transformative in natural language processing, where comprehending context, sentiment, and semantic meaning is complex. By streamlining these tasks, embeddings enable deeper, more sophisticated analysis, thus boosting the effectiveness of machine learning models.
Implications of Model Version Mismatches in Embeddings
Lets discuss the potential impacts and challenges that arise when different versions of embedding models are used within the same domain, specifically focusing on Azure OpenAI embeddings. When embeddings generated by one version of a model are applied or compared with data processed by a different version, various issues can arise. These issues are not only technical but also have practical implications on the efficiency, accuracy, and overall performance of AI-driven applications.
Compatibility and Consistency Issues
Vector Space Misalignment: Different versions of embedding models might organize their vector spaces differently. This misalignment can lead to inaccurate comparisons or analyses when embeddings from different model versions are used together.
Semantic Drift: Over time, models might be trained on new data or with updated techniques, causing shifts in how they interpret and represent language (semantic drift). This drift can cause inconsistencies when integrating new embeddings with those generated by older versions.
Impact on Performance
Reduced Accuracy: Inaccuracies in semantic understanding or context interpretation can occur when different model versions process the same text, leading to reduced accuracy in tasks like search, recommendation, or sentiment analysis.
Inefficiency in Data Processing: Mismatches in model versions can require additional computational resources to reconcile or adjust the differing embeddings, leading to inefficiencies in data processing and increased operational costs.
Best Practices for Upgrading Embedding Models
Upgrading Embedding – Overview
Now lets move to the process of upgrading an embedding model, focusing on the steps you should take before making a change, important questions to consider, and key areas for testing.
Pre-Upgrade Considerations
Assessing the Need for Upgrade:
Why is the upgrade necessary?
What specific improvements or new features does the new model version offer?
How will these changes impact the current system or process?
Understanding Model Changes:
What are the major differences between the current and new model versions?
How might these differences affect data processing and results?
Data Backup and Version Control:
Ensure that current data and model versions are backed up.
Implement version control to maintain a record of changes.
Questions to Ask Before Upgrading
Compatibility with Existing Systems:
Is the new model version compatible with existing data formats and infrastructure?
What adjustments, if any, will be needed to integrate the new model?
Cost-Benefit Analysis:
What are the anticipated costs (monetary, time, resources) of the upgrade?
How do these costs compare to the expected benefits?
Long-Term Support and Updates:
Does the new model version have a roadmap for future updates and support?
How will these future changes impact the system?
Key Areas for Testing
Performance Testing:
Test the new model version for performance improvements or regressions.
Compare accuracy, speed, and resource usage against the current version.
Compatibility Testing:
Ensure that the new model works seamlessly with existing data and systems.
Test for any integration issues or data format mismatches.
Fallback Strategies:
Develop and test fallback strategies in case the new model does not perform as expected.
Ensure the ability to revert to the previous model version if necessary.
Post-Upgrade Best Practices
Monitoring and Evaluation:
Continuously monitor the system’s performance post-upgrade.
Evaluate whether the upgrade meets the anticipated goals and objectives.
Feedback Loop:
Establish a feedback loop to collect user and system performance data.
Use this data to make informed decisions about future upgrades or changes.
Upgrading Embedding – Conclusion
Upgrading an embedding model involves careful consideration, planning, and testing. By following these guidelines, customers can ensure a smooth transition to the new model version, minimizing potential risks and maximizing the benefits of the upgrade.
Use Cases in Azure OpenAI and Beyond
Embedding can significantly enhance the performance of various AI applications by enabling more efficient data handling and processing. Here’s a list of use cases where embeddings can be effectively utilized:
Enhanced Document Retrieval and Analysis: By first performing embeddings on paragraphs or sections of documents, you can store these vector representations in a vector database. This allows for rapid retrieval of semantically similar sections, streamlining the process of analyzing large volumes of text. When integrated with models like GPT, this method can reduce the computational load and improve the efficiency of generating relevant responses or insights.
Semantic Search in Large Datasets: Embeddings can transform vast datasets into searchable vector spaces. In applications like eCommerce or content platforms, this can significantly improve search functionality, allowing users to find products or content based not just on keywords, but on the underlying semantic meaning of their queries.
Recommendation Systems: In recommendation engines, embeddings can be used to understand user preferences and content characteristics. By embedding user profiles and product or content descriptions, systems can more accurately match users with recommendations that are relevant to their interests and past behavior.
Sentiment Analysis and Customer Feedback Interpretation: Embeddings can process customer reviews or feedback by capturing the sentiment and nuanced meanings within the text. This provides businesses with deeper insights into customer sentiment, enabling them to tailor their services or products more effectively.
Language Translation and Localization: Embeddings can enhance machine translation services by understanding the context and nuances of different languages. This is particularly useful in translating idiomatic expressions or culturally specific references, thereby improving the accuracy and relevancy of translations.
Automated Content Moderation: By using embeddings to understand the context and nuance of user-generated content, AI models can more effectively identify and filter out inappropriate or harmful content, maintaining a safe and positive environment on digital platforms.
Personalized Chatbots and Virtual Assistants: Embeddings can be used to improve the understanding of user queries by virtual assistants or chatbots, leading to more accurate and contextually appropriate responses, thus enhancing user experience. With similar logic they could help route natural language to specific APIs. See CompactVectorSearch repository, as an example.
Predictive Analytics in Healthcare: In healthcare data analysis, embeddings can help in interpreting patient data, medical notes, and research papers to predict trends, treatment outcomes, and patient needs more accurately.
In all these use cases, the key advantage of using embeddings is their ability to process and interpret large and complex datasets more efficiently. This not only improves the performance of AI applications but also reduces the computational resources required, especially for high-cost models like GPT. This approach can lead to significant improvements in both the effectiveness and efficiency of AI-driven systems.
Specific Considerations for Azure OpenAI
Model Update Frequency: Understanding how frequently Azure OpenAI updates its models and the nature of these updates (e.g., major vs. minor changes) is crucial.
Backward Compatibility: Assessing whether newer versions of Azure OpenAI’s embedding models maintain backward compatibility with previous versions is key to managing version mismatches.
Version-Specific Features: Identifying features or improvements specific to certain versions of the model helps in understanding the potential impact of using mixed-version embeddings.
Strategies for Mitigation
Version Control in Data Storage: Implementing strict version control for stored embeddings ensures that data remains consistent and compatible with the model version used for its generation.
Compatibility Layers: Developing compatibility layers or conversion tools to adapt older embeddings to newer model formats can help mitigate the effects of version differences.
Baseline Tests: Create few simple baseline tests, that would identify any drift of the embeddings.
Azure OpenAI Model Versioning: Understanding the Process
Azure OpenAI provides a systematic approach to model versioning, applicable to models like text-embedding-ada-002:
Regular Model Releases:
New models are released periodically with improvements and new features.
More on model releases.
Version Update Policies:
Options for auto-updating to new versions or deploying specific versions.
Customizable update policies for flexibility.
Details on update options.
Notifications and Version Maintenance:
Advance notifications for new default versions.
Previous major versions maintained until retirement.
Information on version notifications.
Upgrade Preparation:
Recommendations to read the latest documentation and test applications with new versions.
Importance of updating code and configurations for new features.
Preparing for version upgrades.
Conclusion
Model version mismatches in embeddings, particularly in the context of Azure OpenAI, pose significant challenges that can impact the effectiveness of AI applications. Understanding these challenges and implementing strategies to mitigate their effects is crucial for maintaining the integrity and efficiency of AI-driven systems.
References
“Learn about Azure OpenAI Model Version Upgrades.” Microsoft Tech Community. Link
“OpenAI Unveils New Embedding Model.” InfoQ. Link
“Word2Vec Explained.” Guru99. Link
“GloVe: Global Vectors for Word Representation.” Stanford NLP. Link
Microsoft Tech Community – Latest Blogs –Read More
Lesson Learned #475:Cross-Database Queries Read and Write in Azure SQL Database.
This week, we addressed a service request from a customer who wanted to keep two tables synchronized across different databases on the same Azure SQL Database server. Unfortunately, in Azure SQL Database, it’s not possible to directly call the database in the operation, for instance using the command select * from master.sys.sys_databases. For this reason, I’d like to share an alternative to tackle this limitation.
Sync data across two databases:
To synchronize data across two databases, we have two databases named “Source” and “Target.” Both of these databases contain a table called LocalTable with the following structure:
CREATE TABLE LocalTable (ID BIGINT PRIMARY KEY, NAME VARCHAR(200))
In Source database we are going to run the following script to update in Target database. The first thing we are going to create the external data source:
CREATE MASTER KEY ENCRYPTION BY PASSWORD = ‘MyPwd!’;
CREATE DATABASE SCOPED CREDENTIAL ElasticQueryCred
WITH IDENTITY = ‘userName’,
SECRET = ‘pwd!’;
CREATE EXTERNAL DATA SOURCE MyElasticQueryDataTgt WITH
(TYPE = RDBMS,
LOCATION = ‘servername.database.windows.net’,
DATABASE_NAME = ‘target’, — remote database
CREDENTIAL = ElasticQueryCred,
);
Next we will a store procedure that will receive the parameters and call sp_execute_remote to perform updates in the target database.
CREATE PROCEDURE SyncOtherTable(@ID BIGINT, @Name Varchar(200))
AS
BEGIN
BEGIN TRANSACTION
IF EXISTS( SELECT TOP 1 ID FROM LocalTable WHERE ID = @ID)
BEGIN
UPDATE LocalTable SET Name = @Name WHERE ID = @ID
END
ELSE
BEGIN
INSERT INTO LocalTable (ID,NAME) VALUES(@ID,@Name)
END
EXEC sp_execute_remote
@data_source = N’MyElasticQueryDataTgt’,
@stmt = N’EXEC SyncOtherTable , @Names’,
@params = N’@IDs BIGINT, @Names VARCHAR(200)’,
= @ID,
@Names = @Name;
COMMIT TRANSACTION
END
In the target database we will create the store procedure:
create PROCEDURE SyncOtherTable(@ID BIGINT, @Name Varchar(200))
AS
BEGIN
BEGIN TRANSACTION
IF EXISTS( SELECT TOP 1 ID FROM LocalTable WHERE ID = @ID)
BEGIN
UPDATE LocalTable SET Name = @Name WHERE ID = @ID
END
ELSE
BEGIN
INSERT INTO LocalTable (ID,NAME) VALUES(@ID,@Name)
END
COMMIT TRANSACTION
END
At this point, to synchronize the data in the Target database, we need to run the following T-SQL command in the Source database:
EXEC SyncOtherTable 3,’Demo’
Read data across two databases:
To read data across two databases in a similar situation, consider an example where we have a stored procedure called GetDataFromLocalTableTarget defined in the Source database. The definition of this stored procedure is as follows:
CREATE PROCEDURE GetDataFromLocalTableTarget
@ID BIGINT,
@NameOut VARCHAR(200) OUTPUT
AS
BEGIN
DECLARE @TempTable TABLE (Name VARCHAR(200), [$ShardName] VARCHAR(200));
INSERT INTO @TempTable
EXEC sp_execute_remote
@data_source = N’MyElasticQueryDataTgt’,
@stmt = N’SELECT Name FROM LocalTable WHERE ID = ‘,
@params = N’@IDs BIGINT’,
= @ID;
— Selecciona el nombre desde la tabla temporal y lo asigna a la variable de salida
SELECT TOP 1 @NameOut = Name FROM @TempTable;
END;
Basically, we need to call this store procedure to obtain the data from the target database.
DECLARE @MyName VARCHAR(200);
EXEC GetDataFromLocalTableTarget @ID = 2, @NameOut = @MyName OUTPUT;
SELECT @MyName AS ResultName;
Other option is create another procedure sending the External Data Source, statement and parameters.
CREATE PROCEDURE GetDataFromLocalTableTargetDynamic
@ID BIGINT,
@stmt NVARCHAR(MAX),
@params NVARCHAR(MAX),
@DataSource NVARCHAR(MAX),
@NameOut VARCHAR(200) OUTPUT
AS
BEGIN
DECLARE @TempTable TABLE (Name VARCHAR(200), [$ShardName] VARCHAR(200));
INSERT INTO @TempTable
EXEC sp_execute_remote
@data_source = @DataSource,
@stmt = @stmt,
@params = @params,
= @ID;
— Selecciona el nombre desde la tabla temporal y lo asigna a la variable de salida
SELECT TOP 1 @NameOut = Name FROM @TempTable;
END;
and call it
DECLARE @MyName VARCHAR(200);
EXEC GetDataFromLocalTableTargetDynamic @ID = 2,
@stmt = N’SELECT Name FROM LocalTable WHERE ID = ‘,
@params = N’@IDs BIGINT’,
@DataSource = N’MyElasticQueryDataTgt’,
@NameOut = @MyName OUTPUT;
SELECT @MyName AS ResultName;
Microsoft Tech Community – Latest Blogs –Read More